fix(dbml-to-json): improve multi schema handling

Handle the case where the DBML code include multi schema.

Author: BOCOVO

packages/dbml-to-json-table-schema/src/constants/schema.ts

@@ -0,0 +1 @@
+export const DEFAULT_SCHEMA_NAME = "public";

packages/dbml-to-json-table-schema/src/utils/computeNameWithSchemaName.ts

@@ -0,0 +1,33 @@
+import { DEFAULT_SCHEMA_NAME } from "../constants/schema";
+
+import type Enum from "@dbml/core/types/model_structure/enum";
+import type Table from "@dbml/core/types/model_structure/table";
+
+export const computeNameWithSchemaName = (
+  objectName: string,
+  schemaName?: string,
+): string => {
+  if (
+    schemaName !== undefined &&
+    schemaName !== null &&
+    schemaName !== DEFAULT_SCHEMA_NAME
+  ) {
+    return `${schemaName}.${objectName}`;
+  }
+
+  return objectName;
+};
+
+export const getTableFullName = (table: Table): string => {
+  // unfortunately the Table type from dbml package not define the schemaName property
+  // while it exists
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  return computeNameWithSchemaName(table.name, (table as any).schemaName);
+};
+
+export const getEnumFullName = (_enum: Enum): string => {
+  // unfortunately the Enum type from dbml package not define the schemaName property
+  // while it exists
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  return computeNameWithSchemaName(_enum.name, (_enum as any).schemaName);
+};

packages/dbml-to-json-table-schema/src/utils/createEnumsSet.ts

@@ -1,10 +1,12 @@
+import { getEnumFullName } from "./computeNameWithSchemaName";
+
 import type Enum from "@dbml/core/types/model_structure/enum";
 
 export const createEnumsSet = (enums: Enum[]): Set<string> => {
   const map = new Set<string>();
 
   enums.forEach((enumObj) => {
-    map.add(enumObj.name);
+    map.add(getEnumFullName(enumObj));
   });
 
   return map;

packages/dbml-to-json-table-schema/src/utils/transfomers/dbmlEnumToJSONTableEnum.ts

@@ -1,18 +1,19 @@
 import { type JSONTableEnum } from "shared/types/tableSchema";
 
+import { getEnumFullName } from "../computeNameWithSchemaName";
+
 import type Enum from "@dbml/core/types/model_structure/enum";
 
-export const dbmlEnumToJSONTableEnum = ({
-  values,
-  name,
-}: Enum): JSONTableEnum => {
+export const dbmlEnumToJSONTableEnum = (_enum: Enum): JSONTableEnum => {
   return {
-    name,
-    values: values.map<JSONTableEnum["values"][number]>(({ name, note }) => ({
-      name,
-      // the note returned by the dbml parser is not string
-      // but an object there is an typing error in their package
-      note: (note as any)?.value,
-    })),
+    name: getEnumFullName(_enum),
+    values: _enum.values.map<JSONTableEnum["values"][number]>(
+      ({ name, note }) => ({
+        name,
+        // the note returned by the dbml parser is not string
+        // but an object there is an typing error in their package
+        note: (note as any)?.value,
+      }),
+    ),
   };
 };

packages/dbml-to-json-table-schema/src/utils/transfomers/dbmlFieldToJSONTableField.ts

@@ -1,6 +1,8 @@
 import { type JSONTableField } from "shared/types/tableSchema";
 import { computeRelationalFieldKey } from "shared/utils/computeRelationalFieldKey";
 
+import { computeNameWithSchemaName } from "../computeNameWithSchemaName";
+
 import type Field from "@dbml/core/types/model_structure/field";
 
 interface DbmlToJSONTableFieldParams {
@@ -28,6 +30,11 @@ export const dbmlFieldToJSONTableField = ({
   const fieldKey = computeRelationalFieldKey(ownerTable, name);
 
   const hasRelation = relationalFieldMap.has(fieldKey);
+  const typeName = computeNameWithSchemaName(
+    type.type_name as string,
+    type.schemaName as string | undefined,
+  );
+
   return {
     name,
     pk,
@@ -37,8 +44,8 @@ export const dbmlFieldToJSONTableField = ({
     note: (note as any)?.value,
     not_null,
     type: {
-      type_name: type.type_name,
-      is_enum: enumsMap.has(type.type_name as string),
+      type_name: typeName,
+      is_enum: enumsMap.has(typeName),
     },
     is_relation: hasRelation,
     relational_tables: hasRelation ? relationalFieldMap.get(fieldKey) : null,

packages/dbml-to-json-table-schema/src/utils/transfomers/dbmlRefEndpointToJSONTableRefEndpoint.ts

@@ -1,15 +1,18 @@
 import { type JSONTableRef } from "shared/types/tableSchema";
 
+import { computeNameWithSchemaName } from "../computeNameWithSchemaName";
+
 import type Endpoint from "@dbml/core/types/model_structure/endpoint";
 
 export const dbmlRefEndpointToJSONTableRefEndpoint = ({
   tableName,
   fieldNames,
   relation,
+  schemaName,
 }: Endpoint): JSONTableRef["endpoints"][number] => {
   return {
     relation,
-    tableName,
+    tableName: computeNameWithSchemaName(tableName, schemaName),
     fieldNames,
   };
 };

packages/dbml-to-json-table-schema/src/utils/transfomers/dbmlTableToJSONTableTable.ts

@@ -1,17 +1,21 @@
 import { type JSONTableTable } from "shared/types/tableSchema";
 
+import { getTableFullName } from "../computeNameWithSchemaName";
+
 import { dbmlFieldToJSONTableField } from "./dbmlFieldToJSONTableField";
 import { dbmlIndexToJSONTableIndex } from "./dbmlIndexToJSONTableIndex";
 
 import type Table from "@dbml/core/types/model_structure/table";
 
 export const dbmlTableToJSONTableTable = (
-  { name, note, headerColor, fields, indexes }: Table,
+  table: Table,
   relationalFieldMap: Map<string, string[]>,
   enumsMap: Set<string>,
 ): JSONTableTable => {
+  const { name, note, headerColor, fields, indexes } = table;
+
   return {
-    name,
+    name: getTableFullName(table),
     headerColor,
     // the note returned by the dbml parser is not string
     // but an object there is an typing error in their package

packages/dbml-to-json-table-schema/src/validators/validateRefs.ts

@@ -1,26 +1,34 @@
 import { TableNotExistError } from "../errors/TableNotExistError";
 import { FieldNotExistsError } from "../errors/FieldNotExistsError";
+import {
+  computeNameWithSchemaName,
+  getTableFullName,
+} from "../utils/computeNameWithSchemaName";
 
 import type Endpoint from "@dbml/core/types/model_structure/endpoint";
 import type Ref from "@dbml/core/types/model_structure/ref";
 import type Table from "@dbml/core/types/model_structure/table";
 
-
 export const validateRefs = (refs: Ref[], tables: Table[]): void => {
   const tableMap = new Map<string, Table>();
   tables.forEach((table) => {
-    tableMap.set(table.name, table);
+    const tableName = getTableFullName(table);
+    tableMap.set(tableName, table);
   });
 
   refs.forEach((ref) => {
     ref.endpoints.forEach((endpoint) => {
-      if (tableMap.has(endpoint.tableName)) {
+      const relatedTableFullName = computeNameWithSchemaName(
+        endpoint.tableName,
+        endpoint.schemaName,
+      );
+      if (tableMap.has(relatedTableFullName)) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        validateEndpoint(endpoint, tableMap.get(endpoint.tableName)!);
+        validateEndpoint(endpoint, tableMap.get(relatedTableFullName)!);
         return;
       }
 
-      throw new TableNotExistError(endpoint.tableName);
+      throw new TableNotExistError(relatedTableFullName);
     });
   });
 };

packages/shared/types/tableSchema.ts

@@ -46,7 +46,10 @@ export interface JSONTableIndex
 }
 
 export interface JSONTableTable
-  extends PartialRequired<Pick<Table, "name" | "note" | "headerColor">, "name"> {
+  extends PartialRequired<
+    Pick<Table, "name" | "note" | "headerColor">,
+    "name"
+  > {
   fields: JSONTableField[];
   indexes: JSONTableIndex[];
 }