@dbml/core 2.2.0 → 2.4.0

package/types/model_structure/enumValue.d.ts

@@ -0,0 +1,39 @@
+import { NormalizedDatabase } from './database';
+import DbState from './dbState';
+import Element, { Token } from './element';
+import Enum from './enum';
+interface RawEnumValue {
+    name: string;
+    token: Token;
+    note: string;
+    _enum: Enum;
+}
+declare class EnumValue extends Element {
+    name: string;
+    note: string;
+    _enum: Enum;
+    dbState: DbState;
+    constructor({ name, token, note, _enum }: RawEnumValue);
+    generateId(): void;
+    export(): {
+        name: string;
+        note: string;
+    };
+    exportParentIds(): {
+        enumId: number;
+    };
+    shallowExport(): {
+        name: string;
+        note: string;
+    };
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedEnumValue {
+    [_id: number]: {
+        id: number;
+        name: string;
+        note: string;
+        enumId: number;
+    };
+}
+export default EnumValue;

package/types/model_structure/field.d.ts

@@ -0,0 +1,77 @@
+import { NormalizedDatabase } from './database';
+import DbState from './dbState';
+import Element, { Token } from './element';
+import Endpoint from './endpoint';
+import Enum from './enum';
+import Table from './table';
+interface RawField {
+    name: string;
+    type: any;
+    unique: boolean;
+    pk: boolean;
+    token: Token;
+    not_null: boolean;
+    note: string;
+    dbdefault: any;
+    increment: boolean;
+    table: Table;
+}
+declare class Field extends Element {
+    name: string;
+    type: any;
+    unique: boolean;
+    pk: boolean;
+    dbState: DbState;
+    not_null: boolean;
+    note: string;
+    dbdefault: any;
+    increment: boolean;
+    table: Table;
+    endpoints: Endpoint[];
+    _enum: Enum;
+    constructor({ name, type, unique, pk, token, not_null, note, dbdefault, increment, table }: RawField);
+    generateId(): void;
+    pushEndpoint(endpoint: any): void;
+    export(): {
+        name: string;
+        type: any;
+        unique: boolean;
+        pk: boolean;
+        not_null: boolean;
+        note: string;
+        dbdefault: any;
+        increment: boolean;
+    };
+    exportParentIds(): {
+        tableId: number;
+        enumId: number;
+    };
+    exportChildIds(): {
+        endpointIds: number[];
+    };
+    shallowExport(): {
+        name: string;
+        type: any;
+        unique: boolean;
+        pk: boolean;
+        not_null: boolean;
+        note: string;
+        dbdefault: any;
+        increment: boolean;
+    };
+    normalize(model: NormalizedDatabase): 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;
+    };
+}
+export default Field;

package/types/model_structure/indexColumn.d.ts

@@ -0,0 +1,37 @@
+import { NormalizedDatabase } from './database';
+import DbState from './dbState';
+import Element from './element';
+import Index from './indexes';
+declare class IndexColumn extends Element {
+    type: any;
+    value: any;
+    index: Index;
+    dbState: DbState;
+    constructor({ type, value, index }: {
+        type: any;
+        value: any;
+        index: any;
+    });
+    generateId(): void;
+    export(): {
+        type: any;
+        value: any;
+    };
+    exportParentIds(): {
+        indexId: number;
+    };
+    shallowExport(): {
+        type: any;
+        value: any;
+    };
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedIndexColumn {
+    [_id: number]: {
+        id: number;
+        type: any;
+        value: any;
+        indexId: number;
+    };
+}
+export default IndexColumn;

package/types/model_structure/indexes.d.ts

@@ -0,0 +1,74 @@
+import { NormalizedDatabase } from './database';
+import DbState from './dbState';
+import Element, { Token } from './element';
+import IndexColumn from './indexColumn';
+import Table from './table';
+interface RawIndex {
+    columns: IndexColumn;
+    type: any;
+    unique: boolean;
+    pk: string;
+    name: string;
+    note: string;
+    table: Table;
+    token: Token;
+}
+declare class Index extends Element {
+    columns: IndexColumn[];
+    type: any;
+    unique: boolean;
+    pk: string;
+    name: string;
+    note: string;
+    table: Table;
+    dbState: DbState;
+    constructor({ columns, type, unique, pk, token, name, note, table }: RawIndex);
+    generateId(): void;
+    processIndexColumns(rawColumns: any): void;
+    pushIndexColumn(column: any): void;
+    checkIndexColumn(column: any): void;
+    export(): {
+        columns: {
+            type: any;
+            value: any;
+        }[];
+        name: string;
+        type: any;
+        unique: boolean;
+        pk: string;
+        note: string;
+    };
+    exportChild(): {
+        columns: {
+            type: any;
+            value: any;
+        }[];
+    };
+    exportChildIds(): {
+        columnIds: number[];
+    };
+    exportParentIds(): {
+        tableId: number;
+    };
+    shallowExport(): {
+        name: string;
+        type: any;
+        unique: boolean;
+        pk: string;
+        note: string;
+    };
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedIndex {
+    [_id: number]: {
+        id: number;
+        name: string;
+        type: any;
+        unique: boolean;
+        pk: string;
+        note: string;
+        columnIds: number[];
+        tableId: number;
+    };
+}
+export default Index;

package/types/model_structure/ref.d.ts

@@ -0,0 +1,66 @@
+import Element, { Token } from './element';
+import Endpoint from './endpoint';
+import Schema from './schema';
+import DbState from './dbState';
+import Database, { NormalizedDatabase } from './database';
+interface RawRef {
+    name: string;
+    endpoints: Endpoint[];
+    onDelete: any;
+    onUpdate: any;
+    token: Token;
+    schema: Schema;
+}
+declare class Ref extends Element {
+    name: string;
+    endpoints: Endpoint[];
+    onDelete: any;
+    onUpdate: any;
+    schema: Schema;
+    dbState: DbState;
+    id: number;
+    database: Database;
+    constructor({ name, endpoints, onDelete, onUpdate, token, schema }: RawRef);
+    generateId(): void;
+    processEndpoints(rawEndpoints: any): void;
+    equals(ref: any): any;
+    export(): {
+        endpoints: {
+            schemaName: string;
+            tableName: string;
+            fieldNames: string[];
+            relation: any;
+        }[];
+        name: string;
+        onDelete: any;
+        onUpdate: any;
+    };
+    shallowExport(): {
+        name: string;
+        onDelete: any;
+        onUpdate: any;
+    };
+    exportChild(): {
+        endpoints: {
+            schemaName: string;
+            tableName: string;
+            fieldNames: string[];
+            relation: any;
+        }[];
+    };
+    exportChildIds(): {
+        endpointIds: number[];
+    };
+    exportParentIds(): {
+        schemaId: number;
+    };
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedRef {
+    [_id: number]: {
+        id: number;
+        endpointIds: number[];
+        schemaId: number;
+    };
+}
+export default Ref;

package/types/model_structure/schema.d.ts

@@ -0,0 +1,188 @@
+import Table from './table';
+import Element, { Token } from './element';
+import Enum from './enum';
+import TableGroup from './tableGroup';
+import Ref from './ref';
+import Database, { NormalizedDatabase } from './database';
+import DbState from './dbState';
+export interface RawSchema {
+    name: string;
+    alias?: string;
+    note?: string;
+    tables?: Table[];
+    refs?: Ref[];
+    enums?: Enum[];
+    tableGroups?: TableGroup[];
+    token?: Token;
+    database: Database;
+}
+declare class Schema extends Element {
+    name: string;
+    alias: string;
+    note: string;
+    tables: Table[];
+    refs: Ref[];
+    enums: Enum[];
+    tableGroups: TableGroup[];
+    database: Database;
+    dbState: DbState;
+    constructor({ name, alias, note, tables, refs, enums, tableGroups, token, database }: RawSchema);
+    generateId(): void;
+    processTables(rawTables: any): void;
+    pushTable(table: any): void;
+    checkTable(table: any): void;
+    findTable(tableName: string): Table;
+    processEnums(rawEnums: any): void;
+    pushEnum(_enum: any): void;
+    checkEnum(_enum: any): void;
+    bindEnumToField(_enum: any): void;
+    processRefs(rawRefs: any): void;
+    pushRef(ref: any): void;
+    checkRef(ref: any): void;
+    processTableGroups(rawTableGroups: any): void;
+    pushTableGroup(tableGroup: any): void;
+    checkTableGroup(tableGroup: any): void;
+    checkSameId(schema: any): boolean;
+    export(): {
+        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;
+    };
+    exportChild(): {
+        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;
+        }[];
+    };
+    exportChildIds(): {
+        tableIds: number[];
+        enumIds: number[];
+        tableGroupIds: number[];
+        refIds: number[];
+    };
+    exportParentIds(): {
+        databaseId: number;
+    };
+    shallowExport(): {
+        name: string;
+        note: string;
+        alias: string;
+    };
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedSchema {
+    [_id: number]: {
+        id: number;
+        name: string;
+        note: string;
+        alias: string;
+        tableIds: number[];
+        enumIds: number[];
+        tableGroupIds: number[];
+        refIds: number[];
+        databaseId: number;
+    };
+}
+export default Schema;

package/types/model_structure/table.d.ts

@@ -0,0 +1,118 @@
+import Element, { Token } from './element';
+import Field from './field';
+import Index from './indexes';
+import Schema from './schema';
+import DbState from './dbState';
+import TableGroup from './tableGroup';
+import { NormalizedDatabase } from './database';
+interface RawTable {
+    name: string;
+    alias: string;
+    note: string;
+    fields: Field[];
+    indexes: Index[];
+    schema: Schema;
+    token: Token;
+    headerColor: string;
+}
+declare class Table extends Element {
+    name: string;
+    alias: string;
+    note: string;
+    fields: Field[];
+    indexes: Index[];
+    schema: Schema;
+    headerColor: string;
+    dbState: DbState;
+    id: number;
+    group: TableGroup;
+    constructor({ name, alias, note, fields, indexes, schema, token, headerColor }: RawTable);
+    generateId(): void;
+    processFields(rawFields: any): void;
+    pushField(field: any): void;
+    checkField(field: any): void;
+    processIndexes(rawIndexes: any): void;
+    pushIndex(index: any): void;
+    checkIndex(index: any): void;
+    findField(fieldName: any): Field;
+    checkSameId(table: any): boolean;
+    export(): {
+        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;
+    };
+    exportChild(): {
+        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;
+        }[];
+    };
+    exportChildIds(): {
+        fieldIds: number[];
+        indexIds: number[];
+    };
+    exportParentIds(): {
+        schemaId: number;
+        groupId: number;
+    };
+    shallowExport(): {
+        name: string;
+        alias: string;
+        note: string;
+        headerColor: string;
+    };
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedTable {
+    [id: number]: {
+        id: number;
+        name: string;
+        alias: string;
+        note: string;
+        headerColor: string;
+        fieldIds: number[];
+        indexIds: number[];
+        schemaId: number;
+        groupId: number;
+    };
+}
+export default Table;

package/types/model_structure/tableGroup.d.ts

@@ -0,0 +1,54 @@
+import { NormalizedDatabase } from './database';
+import DbState from './dbState';
+import Element from './element';
+import Schema from './schema';
+import Table from './table';
+declare class TableGroup extends Element {
+    name: string;
+    tables: Table[];
+    schema: Schema;
+    dbState: DbState;
+    id: number;
+    constructor({ name, token, tables, schema }: {
+        name: any;
+        token: any;
+        tables?: any[];
+        schema: any;
+    });
+    generateId(): void;
+    processTables(rawTables: any): void;
+    pushTable(table: any): void;
+    checkTable(table: any): void;
+    export(): {
+        tables: {
+            tableName: string;
+            schemaName: string;
+        }[];
+        name: string;
+    };
+    exportChild(): {
+        tables: {
+            tableName: string;
+            schemaName: string;
+        }[];
+    };
+    exportChildIds(): {
+        tableIds: number[];
+    };
+    exportParentIds(): {
+        schemaId: number;
+    };
+    shallowExport(): {
+        name: string;
+    };
+    normalize(model: NormalizedDatabase): void;
+}
+export interface NormalizedTableGroup {
+    [_id: number]: {
+        id: number;
+        name: string;
+        tableIds: number[];
+        schemaId: number;
+    };
+}
+export default TableGroup;

package/types/parse/Parser.d.ts

@@ -0,0 +1,11 @@
+import Database, { RawDatabase } from '../model_structure/database';
+declare class Parser {
+    static parseJSONToDatabase(rawDatabase: RawDatabase): Database;
+    static parseMySQLToJSON(str: string): RawDatabase;
+    static parsePostgresToJSON(str: string): RawDatabase;
+    static parseDBMLToJSON(str: string): RawDatabase;
+    static parseSchemaRbToJSON(str: string): RawDatabase;
+    static parseMSSQLToJSON(str: string): RawDatabase;
+    static parse(str: string, format: 'mysql' | 'postgres' | 'dbml' | 'schemarb' | 'mssql' | 'json'): Database;
+}
+export default Parser;