chore(prisma-parser): create utility to lookup for relation

Author: BOCOVO

packages/prisma-to-json-table-schema/src/utils/transformers/intermediate/lookForRelation.ts

@@ -0,0 +1,88 @@
+import { type Field } from "@mrleebo/prisma-ast";
+
+import { getFieldTypeName } from "../getFieldTypeName";
+
+import { isKeyValue, isRelationArray, isRelationNode } from "@/utils/isTypeOf";
+import {
+  type RelationType,
+  type RawRelationInfo,
+} from "@/types/intermediateFormattedNode";
+import { scalarFieldType } from "@/constants/scalarFieldType";
+
+export const lookForRelation = (
+  field: Field,
+  tableName: string,
+  registerRelation: (config: RawRelationInfo) => void,
+  registerInverseRelation: (name: string, info: RelationType) => void,
+): void => {
+  const fieldType = getFieldTypeName(field.fieldType);
+
+  let relationFields: string[] = [];
+  let relationReferences: string[] = [];
+  let relationName: string | undefined;
+
+  if (field.attributes !== undefined) {
+    for (const attr of field.attributes) {
+      if (attr.args === undefined || !isRelationNode(attr)) continue;
+
+      for (const argument of attr.args) {
+        if (typeof argument.value === "string") {
+          relationName = argument.value;
+          continue;
+        }
+
+        if (!isKeyValue(argument.value)) {
+          continue;
+        }
+
+        if (
+          argument.value.key === "name" &&
+          typeof argument.value.value === "string"
+        ) {
+          relationName = argument.value.value;
+        }
+
+        if (!isRelationArray(argument.value.value)) continue;
+
+        if (argument.value.key === "fields") {
+          relationFields = argument.value.value.args;
+        }
+
+        if (argument.value.key === "references") {
+          relationReferences = argument.value.value.args;
+        }
+      }
+
+      if (
+        relationFields.length > 0 &&
+        relationFields.length === relationReferences.length
+      ) {
+        relationReferences.forEach((referenceField) => {
+          registerRelation({
+            referenceField,
+            referenceTable: fieldType,
+            table: tableName,
+            field: relationFields[0],
+            name: relationName,
+          });
+        });
+
+        return;
+      }
+    }
+  }
+
+  // check if the field is maybe a inverse relation
+  // that is the if is not a scalar type and not a composite type
+  if (scalarFieldType.has(fieldType)) {
+    return;
+  }
+
+  const inverseKeyPrefix = `${tableName}.${fieldType}`;
+  registerInverseRelation(
+    relationName !== undefined
+      ? `${inverseKeyPrefix}.${relationName}`
+      : inverseKeyPrefix,
+    field.array === true ? "many" : "one",
+  );
+};

packages/prisma-to-json-table-schema/src/utils/transformers/intermediate/tests/lookForRelation.test.ts

@@ -0,0 +1,116 @@
+import { type Field } from "@mrleebo/prisma-ast";
+
+import { lookForRelation } from "../lookForRelation";
+
+import { type RawRelationInfo } from "@/types/intermediateFormattedNode";
+import {
+  namedRelationTable1,
+  namedRelationTable2,
+  productRelation,
+  productTable,
+} from "@/tests/data";
+
+describe("look for relations", () => {
+  test("identifier relations", () => {
+    const registerRelation = jest.fn();
+    const registerInverseRelation = jest.fn();
+    const testTableName = "TestTable";
+
+    lookForRelation(
+      productRelation,
+      testTableName,
+      registerRelation,
+      registerInverseRelation,
+    );
+
+    expect(registerRelation).toHaveBeenCalledWith({
+      table: testTableName,
+      field: "productId",
+      referenceTable: "Product",
+      referenceField: "id",
+    } satisfies RawRelationInfo);
+    expect(registerInverseRelation).not.toHaveBeenCalled();
+  });
+
+  test("will register named relation defined with keyvalue: @relation(name: 'name-here' )", () => {
+    const registerRelation = jest.fn();
+    const registerInverseRelation = jest.fn();
+
+    const testTableName = "TestTable";
+
+    lookForRelation(
+      namedRelationTable1.properties[3] as Field,
+      testTableName,
+      registerRelation,
+      registerInverseRelation,
+    );
+
+    expect(registerRelation).toHaveBeenCalledWith({
+      table: testTableName,
+      field: "player1Id",
+      name: '"player1"',
+      referenceField: "id",
+      referenceTable: "User",
+    } satisfies RawRelationInfo);
+  });
+
+  test("will register named relation defined without keyvalue @relation('name-here')", () => {
+    const registerRelation = jest.fn();
+    const registerInverseRelation = jest.fn();
+
+    const testTableName = "TestTable";
+
+    lookForRelation(
+      namedRelationTable1.properties[5] as Field,
+      testTableName,
+      registerRelation,
+      registerInverseRelation,
+    );
+
+    expect(registerRelation).toHaveBeenCalledWith({
+      table: testTableName,
+      field: "player2Id",
+      name: '"player2"',
+      referenceField: "id",
+      referenceTable: "User",
+    } satisfies RawRelationInfo);
+  });
+
+  test("will register inverse relation", () => {
+    const registerRelation = jest.fn();
+    const registerInverseRelation = jest.fn();
+
+    const testTableName = "TestTable";
+
+    lookForRelation(
+      productTable.properties[6] as Field,
+      testTableName,
+      registerRelation,
+      registerInverseRelation,
+    );
+    expect(registerInverseRelation).toHaveBeenCalledWith(
+      "TestTable.Order",
+      "many",
+    );
+    expect(registerRelation).not.toHaveBeenCalled();
+  });
+
+  test("will register inverse relation with name", () => {
+    const registerRelation = jest.fn();
+    const registerInverseRelation = jest.fn();
+
+    const testTableName = "TestTable";
+
+    lookForRelation(
+      namedRelationTable2.properties[5] as Field,
+      testTableName,
+      registerRelation,
+      registerInverseRelation,
+    );
+    expect(registerInverseRelation).toHaveBeenCalledWith(
+      'TestTable.Match."player1"',
+      "many",
+    );
+    expect(registerRelation).not.toHaveBeenCalled();
+  });
+});