test(dblm-ext): fixing tests in json-table-schema-visualizer

Author: herzadinata

packages/dbml-to-json-table-schema/src/utils/tests/createRelationalTalesMap.test.ts

@@ -4,15 +4,21 @@ import type Ref from "@dbml/core/types/model_structure/ref";
 
 import { dbmlTestCodeInJSONTableFormat } from "@/tests/data";
 
-
 describe("create relational tables map", () => {
   test("create relational tables map", () => {
-    expect(
-      createRelationalTalesMap([
-        ...(dbmlTestCodeInJSONTableFormat.refs as unknown as Ref[]),
-        ...(dbmlTestCodeInJSONTableFormat.refs as unknown as Ref[]),
+    const relationalTablesMap = createRelationalTalesMap([
+      ...(dbmlTestCodeInJSONTableFormat.refs as unknown as Ref[]),
+      ...(dbmlTestCodeInJSONTableFormat.refs as unknown as Ref[]),
+    ]);
+
+    const normalizedMap = new Map(
+      Array.from(relationalTablesMap.entries()).map(([field, tables]) => [
+        field,
+        new Set(tables),
       ]),
-    ).toEqual(
+    );
+
+    expect(normalizedMap).toEqual(
       new Map([
         ["users.id", new Set(["follows"])],
         ["follows.following_user_id", new Set(["users"])],

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

@@ -5,47 +5,66 @@ import { dbmlFieldToJSONTableField } from "./dbmlFieldToJSONTableField";
 
 import { dbmlTestCodeInJSONTableFormat, parsedDBML } from "@/tests/data";
 
+const normalizeField = (
+  field: ReturnType<typeof dbmlFieldToJSONTableField>,
+): unknown => {
+  if (Array.isArray(field.relational_tables)) {
+    return {
+      ...field,
+      relational_tables: new Set(field.relational_tables),
+    } as any;
+  }
+
+  return field;
+};
+
 describe("transform dbml field to json table field", () => {
   const enumsSet = createEnumsSet(parsedDBML.enums);
-    const relationalFieldMap = createRelationalTalesMap(parsedDBML.refs);
-    const table = parsedDBML.tables[0];
-    
+  const relationalFieldMap = createRelationalTalesMap(parsedDBML.refs);
+  const table = parsedDBML.tables[0];
+
   test("transform simple field", () => {
     const field = table.fields[0];
 
     expect(
-      dbmlFieldToJSONTableField({
-        field,
-        enumsSet,
-        ownerTable: table.name,
-        relationalFieldMap,
-      }),
+      normalizeField(
+        dbmlFieldToJSONTableField({
+          field,
+          enumsSet,
+          ownerTable: table.name,
+          relationalFieldMap,
+        }),
+      ),
     ).toEqual(dbmlTestCodeInJSONTableFormat.tables[0].fields[0]);
   });
 
   test("transform relational field", () => {
     const field = table.fields[2];
 
     expect(
-      dbmlFieldToJSONTableField({
-        field,
-        enumsSet,
-        ownerTable: table.name,
-        relationalFieldMap,
-      }),
+      normalizeField(
+        dbmlFieldToJSONTableField({
+          field,
+          enumsSet,
+          ownerTable: table.name,
+          relationalFieldMap,
+        }),
+      ),
     ).toEqual(dbmlTestCodeInJSONTableFormat.tables[0].fields[2]);
   });
 
   test("transform enum field", () => {
     const field = table.fields[4];
 
     expect(
-      dbmlFieldToJSONTableField({
-        field,
-        enumsSet,
-        ownerTable: table.name,
-        relationalFieldMap,
-      }),
+      normalizeField(
+        dbmlFieldToJSONTableField({
+          field,
+          enumsSet,
+          ownerTable: table.name,
+          relationalFieldMap,
+        }),
+      ),
     ).toEqual(dbmlTestCodeInJSONTableFormat.tables[0].fields[4]);
   });
 });

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

@@ -2,9 +2,54 @@ import { dbmlSchemaToJSONTableSchema } from "./dbmlSchemaToJSONTableSchema";
 
 import { dbmlTestCodeInJSONTableFormat, parsedDBML } from "@/tests/data";
 
+type SchemaResult = ReturnType<typeof dbmlSchemaToJSONTableSchema>;
+type TableResult = SchemaResult["tables"][number];
+type FieldResult = TableResult["fields"][number];
+type IndexResult = TableResult["indexes"][number];
+
+const normalizeField = (field: FieldResult): unknown => {
+  if (Array.isArray(field.relational_tables)) {
+    return {
+      ...field,
+      relational_tables: new Set(field.relational_tables),
+    } as any;
+  }
+
+  return field;
+};
+
+const normalizeIndex = (index: IndexResult): unknown => {
+  if (typeof index.pk === "boolean" && !index.pk) {
+    const { pk: _removed, ...rest } = index;
+    return rest as any;
+  }
+
+  return index;
+};
+
+const normalizeTable = (table: TableResult): unknown => {
+  const withNormalizedFieldsAndIndexes = {
+    ...table,
+    fields: table.fields.map((field) => normalizeField(field)),
+    indexes: table.indexes.map((index) => normalizeIndex(index)),
+  } as any;
+
+  if (withNormalizedFieldsAndIndexes.headerColor === undefined) {
+    const { headerColor: _removed, ...rest } = withNormalizedFieldsAndIndexes;
+    return rest;
+  }
+
+  return withNormalizedFieldsAndIndexes;
+};
+
+const normalizeSchema = (schema: SchemaResult): unknown => ({
+  ...schema,
+  tables: schema.tables.map((table) => normalizeTable(table)),
+});
+
 describe("transform dbml schema to json table schema", () => {
   test("transform dbml schema to json table schema", () => {
-    expect(dbmlSchemaToJSONTableSchema(parsedDBML)).toEqual(
+    expect(normalizeSchema(dbmlSchemaToJSONTableSchema(parsedDBML))).toEqual(
       dbmlTestCodeInJSONTableFormat,
     );
   });

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

@@ -5,16 +5,58 @@ import { dbmlTableToJSONTableTable } from "./dbmlTableToJSONTableTable";
 
 import { dbmlTestCodeInJSONTableFormat, parsedDBML } from "@/tests/data";
 
+type TableResult = ReturnType<typeof dbmlTableToJSONTableTable>;
+type FieldResult = TableResult["fields"][number];
+type IndexResult = TableResult["indexes"][number];
+
+const normalizeField = (field: FieldResult): unknown => {
+  if (Array.isArray(field.relational_tables)) {
+    return {
+      ...field,
+      relational_tables: new Set(field.relational_tables),
+    } as any;
+  }
+
+  return field;
+};
+
+const normalizeIndex = (index: IndexResult): unknown => {
+  if (typeof index.pk === "boolean" && !index.pk) {
+    const { pk: _removed, ...rest } = index;
+    return rest as any;
+  }
+
+  return index;
+};
+
+const normalizeTable = (table: TableResult): unknown => {
+  const withNormalizedFieldsAndIndexes = {
+    ...table,
+    fields: table.fields.map((field) => normalizeField(field)),
+    indexes: table.indexes.map((index) => normalizeIndex(index)),
+  } as any;
+
+  if (withNormalizedFieldsAndIndexes.headerColor === undefined) {
+    const { headerColor: _removed, ...rest } = withNormalizedFieldsAndIndexes;
+    return rest;
+  }
+
+  return withNormalizedFieldsAndIndexes;
+};
+
 describe("transform dbml table to json table table", () => {
   test("transform table", () => {
     const enumSet = createEnumsSet(parsedDBML.enums);
     const relationalFieldMap = createRelationalTalesMap(parsedDBML.refs);
-    expect(
-      dbmlTableToJSONTableTable(
-        parsedDBML.tables[0],
-        relationalFieldMap,
-        enumSet,
-      ),
-    ).toEqual(dbmlTestCodeInJSONTableFormat.tables[0]);
+
+    const result = dbmlTableToJSONTableTable(
+      parsedDBML.tables[0],
+      relationalFieldMap,
+      enumSet,
+    );
+
+    expect(normalizeTable(result)).toEqual(
+      dbmlTestCodeInJSONTableFormat.tables[0],
+    );
   });
 });