@dbml/core 6.0.0 → 6.1.0

package/lib/model_structure/field.js

@@ -138,7 +138,7 @@ var Field = /*#__PURE__*/function (_Element) {
   }, {
     key: "shallowExport",
     value: function shallowExport() {
-      var _this$injectedPartial;
+      var _this$injectedPartial, _this$injectedPartial2;
       return {
         name: this.name,
         type: this.type,
@@ -148,7 +148,7 @@ var Field = /*#__PURE__*/function (_Element) {
         note: this.note,
         dbdefault: this.dbdefault,
         increment: this.increment,
-        injectedPartialId: (_this$injectedPartial = this.injectedPartial) === null || _this$injectedPartial === void 0 ? void 0 : _this$injectedPartial.id,
+        injectedPartialId: (_this$injectedPartial = (_this$injectedPartial2 = this.injectedPartial) === null || _this$injectedPartial2 === void 0 ? void 0 : _this$injectedPartial2.id) !== null && _this$injectedPartial !== void 0 ? _this$injectedPartial : null,
         checkIds: this.checks.map(function (check) {
           return check.id;
         })

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/core",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "description": "> TODO: description",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -36,7 +36,7 @@
     "lint:fix": "eslint --fix ."
   },
   "dependencies": {
-    "@dbml/parse": "^6.0.0",
+    "@dbml/parse": "^6.1.0",
     "antlr4": "^4.13.1",
     "lodash": "^4.17.15",
     "parsimmon": "^1.13.0",
@@ -63,7 +63,7 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.46.3"
   },
-  "gitHead": "75a218687814d8b1c538b26908745e0d0ee8b35a",
+  "gitHead": "4897a3e1f59dd9eed89ee4a9f945b4e740e9bc0a",
   "engines": {
     "node": ">=16"
   }

package/types/index.d.ts

@@ -5,3 +5,41 @@ import exporter from './export';
 import { renameTable } from './transform';
 export { renameTable, importer, exporter, ModelExporter, Parser };
 export { CompilerDiagnostic, CompilerError as CompilerDiagnostics, EditorPosition, ErrorCode, WarningLevel, } from './parse/error';
+
+// Export normalized types
+export type {
+    NormalizedDatabase,
+    NormalizedDatabaseIdMap,
+    NormalizedModel,
+    NormalizedSchema,
+    NormalizedSchemaIdMap,
+    NormalizedTable,
+    NormalizedTableIdMap,
+    NormalizedField,
+    NormalizedFieldIdMap,
+    NormalizedIndex,
+    NormalizedIndexIdMap,
+    NormalizedIndexColumn,
+    NormalizedIndexColumnIdMap,
+    NormalizedEnum,
+    NormalizedEnumIdMap,
+    NormalizedEnumValue,
+    NormalizedEnumValueIdMap,
+    NormalizedRef,
+    NormalizedRefIdMap,
+    NormalizedEndpoint,
+    NormalizedEndpointIdMap,
+    NormalizedTableGroup,
+    NormalizedTableGroupIdMap,
+    NormalizedNote,
+    NormalizedNoteIdMap,
+    NormalizedCheck,
+    NormalizedCheckIdMap,
+    NormalizedTablePartial,
+    NormalizedTablePartialIdMap,
+    Project,
+    RawDatabase,
+    TableRecord,
+    NormalizedRecords,
+    RawSchema,
+} from './model_structure';

package/types/model_structure/check.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 import Element, { Token } from './element';
 import Field from './field';
 import Table from './table';
@@ -35,18 +35,20 @@ declare class Check extends Element {
         name: string;
         expression: string;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 
 export interface NormalizedCheck {
-    [_id: number]: {
-        id: number;
-        name: string;
-        expression: string;
-        tableId: number;
-        columnId: number | null;
-        injectedPartialId: number | null;
-    };
+    id: number;
+    name: string;
+    expression: string;
+    tableId: number;
+    columnId: number | null;
+    injectedPartialId: number | null;
+}
+
+export interface NormalizedCheckIdMap {
+    [_id: number]: NormalizedCheck;
 }
 
 export default Check;

package/types/model_structure/database.d.ts

@@ -1,18 +1,18 @@
-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 StickyNote, { NormalizedStickyNote } from './stickyNote';
+import Schema, { NormalizedSchemaIdMap, RawSchema } from './schema';
+import Ref, { NormalizedRefIdMap } from './ref';
+import Enum, { NormalizedEnumIdMap } from './enum';
+import TableGroup, { NormalizedTableGroupIdMap } from './tableGroup';
+import Table, { NormalizedTableIdMap } from './table';
+import StickyNote, { NormalizedNoteIdMap } from './stickyNote';
 import Element, { RawNote, Token } 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';
-import { NormalizedCheck } from './check';
-import TablePartial, { NormalizedTablePartial } from './tablePartial';
+import { NormalizedEndpointIdMap } from './endpoint';
+import { NormalizedEnumValueIdMap } from './enumValue';
+import { NormalizedFieldIdMap } from './field';
+import { NormalizedIndexColumnIdMap } from './indexColumn';
+import { NormalizedIndexIdMap } from './indexes';
+import { NormalizedCheckIdMap } from './check';
+import TablePartial, { NormalizedTablePartialIdMap } from './tablePartial';
 export interface Project {
     note: RawNote;
     database_type: string;
@@ -276,33 +276,36 @@ declare class Database extends Element {
         schemaIds: number[];
         noteIds: number[];
     };
-    normalize(): NormalizedDatabase;
+    normalize(): NormalizedModel;
 }
 export interface NormalizedDatabase {
-    database: {
-        [_id: number]: {
-            id: number;
-            hasDefaultSchema: boolean;
-            note: string;
-            databaseType: string;
-            name: string;
-            schemaIds: number[];
-            noteIds: number[];
-        };
-    };
-    schemas: NormalizedSchema;
-    notes: NormalizedStickyNote;
-    refs: NormalizedRef;
-    enums: NormalizedEnum;
-    tableGroups: NormalizedTableGroup;
-    tables: NormalizedTable;
-    endpoints: NormalizedEndpoint;
-    enumValues: NormalizedEnumValue;
-    indexes: NormalizedIndex;
-    indexColumns: NormalizedIndexColumn;
-    checks: NormalizedCheck;
-    fields: NormalizedField;
-    records: NormalizedRecords;
-    tablePartials: NormalizedTablePartial;
+    id: number;
+    hasDefaultSchema: boolean;
+    note: string | null;
+    databaseType: string;
+    name: string;
+    schemaIds: number[];
+    noteIds: number[];
+}
+
+export interface NormalizedDatabaseIdMap {
+    [_id: number]: NormalizedDatabase;
+}
+
+export interface NormalizedModel {
+    database: NormalizedDatabaseIdMap;
+    schemas: NormalizedSchemaIdMap;
+    endpoints: NormalizedEndpointIdMap;
+    refs: NormalizedRefIdMap;
+    fields: NormalizedFieldIdMap;
+    tables: NormalizedTableIdMap;
+    tableGroups: NormalizedTableGroupIdMap;
+    enums: NormalizedEnumIdMap;
+    enumValues: NormalizedEnumValueIdMap;
+    indexes: NormalizedIndexIdMap;
+    indexColumns: NormalizedIndexColumnIdMap;
+    notes: NormalizedNoteIdMap;
+    checks: NormalizedCheckIdMap;
+    tablePartials: NormalizedTablePartialIdMap;
 }
 export default Database;

package/types/model_structure/endpoint.d.ts

@@ -2,7 +2,7 @@ import Element from './element';
 import Field from './field';
 import Ref from './ref';
 import DbState from './dbState';
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 declare class Endpoint extends Element {
     relation: any;
     schemaName: string;
@@ -39,17 +39,20 @@ declare class Endpoint extends Element {
         relation: any;
     };
     setFields(fieldNames: any, table: any): void;
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedEndpoint {
-    [_id: number]: {
-        id: number;
-        schemaName: string;
-        tableName: string;
-        fieldNames: string[];
-        relation: any;
-        refId: number;
-        fieldIds: number[];
-    };
+    id: number;
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    fieldIds: number[];
+    relation: string;
+    refId: number;
+}
+
+export interface NormalizedEndpointIdMap {
+    [_id: number]: NormalizedEndpoint;
 }
+
 export default Endpoint;

package/types/model_structure/enum.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 import DbState from './dbState';
 import Element, { Token, RawNote } from './element';
 import EnumValue from './enumValue';
@@ -53,16 +53,19 @@ declare class Enum extends Element {
         name: string;
         note: string;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedEnum {
-    [_id: number]: {
-        id: number;
-        name: string;
-        note: string;
-        valueIds: number[];
-        fieldIds: number[];
-        schemaId: number;
-    };
+    id: number;
+    name: string;
+    note: string | null;
+    valueIds: number[];
+    fieldIds: number[];
+    schemaId: number;
+}
+
+export interface NormalizedEnumIdMap {
+    [_id: number]: NormalizedEnum;
 }
+
 export default Enum;

package/types/model_structure/enumValue.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 import DbState from './dbState';
 import Element, { Token, RawNote } from './element';
 import Enum from './enum';
@@ -27,14 +27,17 @@ declare class EnumValue extends Element {
         name: string;
         note: string;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedEnumValue {
-    [_id: number]: {
-        id: number;
-        name: string;
-        note: string;
-        enumId: number;
-    };
+    id: number;
+    name: string;
+    note: string | null;
+    enumId: number;
+}
+
+export interface NormalizedEnumValueIdMap {
+    [_id: number]: NormalizedEnumValue;
 }
+
 export default EnumValue;

package/types/model_structure/field.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 import DbState from './dbState';
 import Element, { Token, RawNote } from './element';
 import Endpoint from './endpoint';
@@ -70,24 +70,30 @@ declare class Field extends Element {
         injectedPartialId?: number;
         checkIds: number[];
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedField {
-    [_id: number]: {
-        id: number;
-        name: string;
-        type: any;
-        unique: boolean;
-        pk: boolean;
-        not_null: boolean;
-        note: string;
-        dbdefault: any;
-        increment: boolean;
-        tableId: number;
-        endpointIds: number[];
-        enumId: number;
-        injectedPartialId?: number;
-        checkIds: number[];
+    id: number;
+    name: string;
+    type: {
+        schemaName: string | null;
+        type_name: string;
     };
+    unique: boolean;
+    pk: boolean;
+    not_null: boolean;
+    note: string | null;
+    dbdefault: unknown;
+    increment: boolean;
+    endpointIds: number[];
+    tableId: number;
+    enumId: number | null;
+    injectedPartialId: number | null;
+    checkIds: number[];
+}
+
+export interface NormalizedFieldIdMap {
+    [_id: number]: NormalizedField;
 }
+
 export default Field;

package/types/model_structure/index.d.ts

@@ -0,0 +1,91 @@
+// Export main classes
+export { default as Database } from './database';
+export { default as Schema } from './schema';
+export { default as Table } from './table';
+export { default as Field } from './field';
+export { default as Index } from './indexes';
+export { default as IndexColumn } from './indexColumn';
+export { default as Enum } from './enum';
+export { default as EnumValue } from './enumValue';
+export { default as Ref } from './ref';
+export { default as Endpoint } from './endpoint';
+export { default as TableGroup } from './tableGroup';
+export { default as StickyNote } from './stickyNote';
+export { default as Check } from './check';
+export { default as TablePartial } from './tablePartial';
+
+// Export normalized individual types
+export type {
+    NormalizedDatabase,
+    NormalizedDatabaseIdMap,
+    NormalizedModel,
+} from './database';
+
+export type {
+    NormalizedSchema,
+    NormalizedSchemaIdMap,
+} from './schema';
+
+export type {
+    NormalizedTable,
+    NormalizedTableIdMap,
+} from './table';
+
+export type {
+    NormalizedField,
+    NormalizedFieldIdMap,
+} from './field';
+
+export type {
+    NormalizedIndex,
+    NormalizedIndexIdMap,
+} from './indexes';
+
+export type {
+    NormalizedIndexColumn,
+    NormalizedIndexColumnIdMap,
+} from './indexColumn';
+
+export type {
+    NormalizedEnum,
+    NormalizedEnumIdMap,
+} from './enum';
+
+export type {
+    NormalizedEnumValue,
+    NormalizedEnumValueIdMap,
+} from './enumValue';
+
+export type {
+    NormalizedRef,
+    NormalizedRefIdMap,
+} from './ref';
+
+export type {
+    NormalizedEndpoint,
+    NormalizedEndpointIdMap,
+} from './endpoint';
+
+export type {
+    NormalizedTableGroup,
+    NormalizedTableGroupIdMap,
+} from './tableGroup';
+
+export type {
+    NormalizedNote,
+    NormalizedNoteIdMap,
+} from './stickyNote';
+
+export type {
+    NormalizedTablePartial,
+    NormalizedTablePartialIdMap,
+} from './tablePartial';
+
+export type {
+    NormalizedCheck,
+    NormalizedCheckIdMap,
+} from './check';
+
+// Export other types
+export type { Project, RawDatabase, TableRecord, NormalizedRecords } from './database';
+export type { RawSchema } from './schema';

package/types/model_structure/indexColumn.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 import DbState from './dbState';
 import Element from './element';
 import Index from './indexes';
@@ -24,14 +24,17 @@ declare class IndexColumn extends Element {
         type: any;
         value: any;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedIndexColumn {
-    [_id: number]: {
-        id: number;
-        type: any;
-        value: any;
-        indexId: number;
-    };
+    id: number;
+    type: string;
+    value: string;
+    indexId: number;
+}
+
+export interface NormalizedIndexColumnIdMap {
+    [_id: number]: NormalizedIndexColumn;
 }
+
 export default IndexColumn;

package/types/model_structure/indexes.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 import DbState from './dbState';
 import Element, { RawNote, Token } from './element';
 import IndexColumn from './indexColumn';
@@ -62,18 +62,22 @@ declare class Index extends Element {
         note: string;
         injectedPartialId?: number;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedIndex {
-    [_id: number]: {
-        id: number;
-        name: string;
-        type: any;
-        unique: boolean;
-        pk: string;
-        note: string;
-        columnIds: number[];
-        tableId: number;
-    };
+    id: number;
+    name: string | null;
+    type: any;
+    unique: boolean;
+    pk: string;
+    note: string | null;
+    columnIds: number[];
+    tableId: number;
+    injectedPartialId?: number;
+}
+
+export interface NormalizedIndexIdMap {
+    [_id: number]: NormalizedIndex;
 }
+
 export default Index;

package/types/model_structure/ref.d.ts

@@ -2,7 +2,7 @@ import Element, { Token } from './element';
 import Endpoint from './endpoint';
 import Schema from './schema';
 import DbState from './dbState';
-import Database, { NormalizedDatabase } from './database';
+import Database, { NormalizedModel } from './database';
 import TablePartial from './tablePartial';
 interface RawRef {
     name: string;
@@ -60,18 +60,21 @@ declare class Ref extends Element {
     exportParentIds(): {
         schemaId: number;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedRef {
-    [_id: number]: {
-        id: number;
-        name?: string;
-        color?: string;
-        onUpdate?: string;
-        onDelete?: string;
-        endpointIds: number[];
-        schemaId: number;
-        injectedPartialId?: number;
-    };
+    id: number;
+    name: string | null;
+    color?: string;
+    onUpdate?: string;
+    onDelete?: string;
+    schemaId: number;
+    endpointIds: number[];
+    injectedPartialId?: number;
+}
+
+export interface NormalizedRefIdMap {
+    [_id: number]: NormalizedRef;
 }
+
 export default Ref;

package/types/model_structure/schema.d.ts

@@ -3,7 +3,7 @@ import Element, { RawNote, Token } from './element';
 import Enum from './enum';
 import TableGroup from './tableGroup';
 import Ref from './ref';
-import Database, { NormalizedDatabase } from './database';
+import Database, { NormalizedModel } from './database';
 import DbState from './dbState';
 export interface RawSchema {
     name: string;
@@ -172,20 +172,23 @@ declare class Schema extends Element {
         note: string;
         alias: string;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedSchema {
-    [_id: number]: {
-        id: number;
-        name: string;
-        note: string;
-        alias: string;
-        tableIds: number[];
-        noteIds: number[];
-        enumIds: number[];
-        tableGroupIds: number[];
-        refIds: number[];
-        databaseId: number;
-    };
+    id: number;
+    name: string;
+    note: string | null;
+    alias: string;
+    tableIds: number[];
+    noteIds: number[];
+    refIds: number[];
+    tableGroupIds: number[];
+    enumIds: number[];
+    databaseId: number;
+}
+
+export interface NormalizedSchemaIdMap {
+    [_id: number]: NormalizedSchema;
 }
+
 export default Schema;

package/types/model_structure/stickyNote.d.ts

@@ -1,7 +1,7 @@
 import Element, { Token } from './element';
 import Database from './database';
 import DbState from './dbState';
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 interface RawStickyNote {
     name: string;
     content: string;
@@ -24,14 +24,17 @@ declare class StickyNote extends Element {
         content: string;
         headerColor: string;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
-export interface NormalizedStickyNote {
-    [id: number]: {
-        id: number;
-        name: string;
-        content: string;
-        headerColor: string;
-    };
+export interface NormalizedNote {
+    id: number;
+    name: string;
+    content: string;
+    headerColor: string | null;
+}
+
+export interface NormalizedNoteIdMap {
+    [id: number]: NormalizedNote;
 }
+
 export default StickyNote;

package/types/model_structure/table.d.ts

@@ -6,7 +6,7 @@ import Schema from './schema';
 import DbState from './dbState';
 import TableGroup from './tableGroup';
 import TablePartial from './tablePartial';
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 
 interface RawTable {
     name: string;
@@ -116,23 +116,25 @@ declare class Table extends Element {
         headerColor: string;
         partials: TablePartial[];
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 
 export interface NormalizedTable {
-    [id: number]: {
-        id: number;
-        name: string;
-        alias: string;
-        note: string;
-        headerColor: string;
-        fieldIds: number[];
-        indexIds: number[];
-        checkIds: number[];
-        schemaId: number;
-        groupId: number;
-        partials: TablePartial[];
-    };
+    id: number;
+    name: string;
+    alias: string | null;
+    note: string | null;
+    headerColor: string;
+    fieldIds: number[];
+    indexIds: number[];
+    checkIds: number[];
+    schemaId: number;
+    groupId: number | null;
+    partials: TablePartial[];
+}
+
+export interface NormalizedTableIdMap {
+    [id: number]: NormalizedTable;
 }
 
 export default Table;

package/types/model_structure/tableGroup.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 import DbState from './dbState';
 import Element, { RawNote, Token} from './element';
 import Schema from './schema';
@@ -53,16 +53,19 @@ declare class TableGroup extends Element {
         note: string;
         color: string;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedTableGroup {
-    [_id: number]: {
-        id: number;
-        name: string;
-        tableIds: number[];
-        schemaId: number;
-        note: string;
-        color: string;
-    };
+    id: number;
+    name: string;
+    note: string | null;
+    color: string;
+    tableIds: number[];
+    schemaId: number;
 }
+
+export interface NormalizedTableGroupIdMap {
+    [_id: number]: NormalizedTableGroup;
+}
+
 export default TableGroup;

package/types/model_structure/tablePartial.d.ts

@@ -3,7 +3,7 @@ import Field from './field';
 import Index from './indexes';
 import Check from './check';
 import DbState from './dbState';
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 
 interface RawTablePartial {
     name: string;
@@ -83,18 +83,21 @@ declare class TablePartial extends Element {
             note: string;
         }[];
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 
 export interface NormalizedTablePartial {
-    [id: number]: {
-        id: number;
-        name: string;
-        note: string;
-        headerColor: string;
-        fieldIds: number[];
-        indexIds: number[];
-    };
+    id: number;
+    name: string;
+    note: string;
+    headerColor: string;
+    fieldIds: number[];
+    indexIds: number[];
+    checkIds: number[];
+}
+
+export interface NormalizedTablePartialIdMap {
+    [id: number]: NormalizedTablePartial;
 }
 
 export default TablePartial;