feat(prisma-parser): added utilities to transform prisma ast to json table schema

Author: BOCOVO

packages/prisma-to-json-table-schema/src/index.ts

@@ -0,0 +1,9 @@
+import { getSchema } from "@mrleebo/prisma-ast";
+import { type JSONTableSchema } from "shared/types/tableSchema";
+
+import { prismaASTToJSONTableSchema } from "./utils/transformers/prismaASTToJSONTableSchema";
+
+export const parsePrismaToJSON = (prismaCode: string): JSONTableSchema => {
+  const rawParsedSchema = getSchema(prismaCode);
+  return prismaASTToJSONTableSchema(rawParsedSchema);
+};

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

@@ -0,0 +1,76 @@
+import { type JSONTableRef } from "shared/types/tableSchema";
+
+import { computeKey } from "../computeKey";
+
+import type {
+  FieldRelationsMap,
+  IntermediateSchema,
+} from "@/types/intermediateFormattedNode";
+
+export const createRefsAndFieldRelationsArray = (
+  rawRelations: IntermediateSchema["rawRelations"],
+  inverseRelationMap: IntermediateSchema["inverseRelationMap"],
+  tablesNames: IntermediateSchema["tablesNames"],
+): [JSONTableRef[], FieldRelationsMap] => {
+  const refs: JSONTableRef[] = [];
+  const allFieldRelations: FieldRelationsMap = new Map();
+
+  const appendFieldRelation = (
+    fieldKey: string,
+    relationName: string,
+  ): void => {
+    if (allFieldRelations.has(fieldKey)) {
+      allFieldRelations.get(fieldKey)?.push(relationName);
+    } else {
+      allFieldRelations.set(fieldKey, [relationName]);
+    }
+  };
+
+  rawRelations.forEach((relation) => {
+    // check if invest relationship exists
+    if (
+      // check all table exists
+      !tablesNames.has(relation.table) &&
+      !tablesNames.has(relation.referenceTable)
+    )
+      return;
+
+    const id = computeKey(
+      relation.referenceTable,
+      relation.table,
+      ...(relation.name !== undefined ? [relation.name] : []),
+    );
+    const relationType = inverseRelationMap.get(id);
+    if (relationType === undefined) return;
+
+    const ref: JSONTableRef = {
+      name: relation.name,
+      endpoints: [
+        {
+          relation: "1",
+          tableName: relation.referenceTable,
+          fieldNames: [relation.referenceField],
+        },
+        {
+          relation: relationType === "many" ? "*" : "1",
+          fieldNames: [relation.field],
+          tableName: relation.table,
+        },
+      ],
+    };
+
+    refs.push(ref);
+
+    appendFieldRelation(
+      computeKey(relation.referenceTable, relation.referenceField),
+      relation.table,
+    );
+
+    appendFieldRelation(
+      computeKey(relation.table, relation.field),
+      relation.referenceTable,
+    );
+  });
+
+  return [refs, allFieldRelations];
+};

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

@@ -0,0 +1,68 @@
+import { type JSONTableEnum } from "shared/types/tableSchema";
+
+import { enumNodeToJSONTableEnum } from "../enumNodeToJSONTableEnum";
+
+import { formatIntermediateTable } from "./formatIntermediateTable";
+
+import type { Schema } from "@mrleebo/prisma-ast";
+
+import {
+  type RawRelationInfo,
+  type IntermediateSchema,
+  type IntermediateTable,
+  type RelationType,
+} from "@/types/intermediateFormattedNode";
+import { isEnumNode, isModelNode, isTypeNode } from "@/utils/isTypeOf";
+
+export const createIntermediateSchema = (
+  nodes: Schema["list"],
+): IntermediateSchema => {
+  const enums: JSONTableEnum[] = [];
+  const tables: IntermediateTable[] = [];
+  const enumsNames = new Set<string>();
+  const types = new Set<string>();
+  const rawRelations: RawRelationInfo[] = [];
+  const inverseRelationMap = new Map<string, RelationType>();
+  const tablesNames = new Set<string>();
+
+  const registerInverseRelation = (name: string, type: RelationType): void => {
+    inverseRelationMap.set(name, type);
+  };
+
+  const registerRawRelation = (info: RawRelationInfo): void => {
+    rawRelations.push(info);
+  };
+
+  for (const node of nodes) {
+    if (isEnumNode(node)) {
+      const _enum = enumNodeToJSONTableEnum(node);
+      enumsNames.add(_enum.name);
+      enums.push(_enum);
+    }
+
+    if (isModelNode(node)) {
+      tablesNames.add(node.name);
+      tables.push(
+        formatIntermediateTable(
+          node,
+          registerRawRelation,
+          registerInverseRelation,
+        ),
+      );
+    }
+
+    if (isTypeNode(node)) {
+      types.add(node.name);
+    }
+  }
+
+  return {
+    enums,
+    tables,
+    enumsNames,
+    rawRelations,
+    inverseRelationMap,
+    tablesNames,
+    compositeTypesNames: types,
+  };
+};

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

@@ -0,0 +1,29 @@
+import { type JSONTableField } from "shared/types/tableSchema";
+
+import { computeKey } from "../computeKey";
+
+import type {
+  FieldRelationsMap,
+  IntermediateField,
+} from "@/types/intermediateFormattedNode";
+
+export const intermediateFieldToJSONTableField = (
+  tableName: string,
+  intermediateField: IntermediateField,
+  enumsSet: Set<string>,
+  fieldRelationTable: FieldRelationsMap,
+): JSONTableField => {
+  const isEnum = enumsSet.has(intermediateField.type.type_name);
+
+  const keyInFieldRelationTable = computeKey(tableName, intermediateField.name);
+  const relationship = fieldRelationTable.get(keyInFieldRelationTable);
+
+  const field: JSONTableField = {
+    ...intermediateField,
+    type: { type_name: intermediateField.type.type_name, is_enum: isEnum },
+    is_relation: relationship !== undefined && relationship.length > 0,
+    relational_tables: relationship,
+  };
+
+  return field;
+};

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

@@ -0,0 +1,25 @@
+import { type JSONTableTable } from "shared/types/tableSchema";
+
+import { intermediateFieldToJSONTableField } from "./intermediateFieldToJSONTableField";
+
+import {
+  type FieldRelationsMap,
+  type IntermediateTable,
+} from "@/types/intermediateFormattedNode";
+
+export const intermediateTableToJSONTableTable = (
+  { fields: intermediateFields, name, indexes }: IntermediateTable,
+  enumsSet: Set<string>,
+  fieldRelationTable: FieldRelationsMap,
+): JSONTableTable => {
+  const fields = intermediateFields.map((intermediateField) =>
+    intermediateFieldToJSONTableField(
+      name,
+      intermediateField,
+      enumsSet,
+      fieldRelationTable,
+    ),
+  );
+
+  return { name, fields, indexes };
+};

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

@@ -0,0 +1,35 @@
+import { type Schema } from "@mrleebo/prisma-ast";
+import { type JSONTableSchema } from "shared/types/tableSchema";
+
+import { createIntermediateSchema } from "./intermediate/createIntermediateSchema";
+import { createRefsAndFieldRelationsArray } from "./createRefsFromPrismaASTNodes";
+import { intermediateTableToJSONTableTable } from "./intermediateTableToJSONTableTable";
+
+export const prismaASTToJSONTableSchema = (
+  prismaAST: Schema,
+): JSONTableSchema => {
+  const {
+    enums,
+    tables: intermediateTables,
+    enumsNames,
+    rawRelations,
+    inverseRelationMap,
+    tablesNames,
+  } = createIntermediateSchema(prismaAST.list);
+
+  const [refs, fieldRelationsArray] = createRefsAndFieldRelationsArray(
+    rawRelations,
+    inverseRelationMap,
+    tablesNames,
+  );
+
+  const tables = intermediateTables.map((intermediateTable) => {
+    return intermediateTableToJSONTableTable(
+      intermediateTable,
+      enumsNames,
+      fieldRelationsArray,
+    );
+  });
+
+  return { tables, enums, refs };
+};