@rapidd/build 1.2.3 → 2.0.1

package/src/parsers/prismaFilterBuilder.js

@@ -1,422 +0,0 @@
-/**
- * Prisma Filter Builder for RLS
- * Generates correct Prisma filter syntax based on schema relationships
- */
-
-class PrismaFilterBuilder {
-  constructor(models, relationships) {
-    this.models = models;
-    this.relationships = relationships || {};
-
-    // Find the user model
-    this.userModel = null;
-    this.userModelName = null;
-    for (const [modelName, modelInfo] of Object.entries(models)) {
-      if (modelName.toLowerCase() === 'user' || modelName.toLowerCase() === 'users') {
-        this.userModel = modelInfo;
-        this.userModelName = modelName;
-        break;
-      }
-    }
-  }
-
-  /**
-   * Build a Prisma filter from SQL RLS analysis
-   * @param {string} modelName - The model to build filter for
-   * @param {Object} analysis - SQL analysis from DeepSQLAnalyzer
-   * @param {string} userVar - User variable name (default: 'user')
-   * @returns {string} - Prisma filter code
-   */
-  buildFilter(modelName, analysis, userVar = 'user') {
-    if (!analysis.filters || analysis.filters.length === 0) {
-      return '{}';
-    }
-
-    const filters = [];
-    const modelInfo = this.models[modelName];
-
-    for (const filter of analysis.filters) {
-      if (filter.type.startsWith('user_') || filter.type.startsWith('session_')) {
-        // This is a user field comparison
-        const userField = filter.userField || filter.type.replace(/^(user_|session_)/, '');
-
-        // Skip role filters - they're runtime checks, not data filters
-        if (filter.type === 'user_role' || userField === 'role') {
-          continue;
-        }
-
-        const prismaFilter = this.buildUserFieldFilter(modelName, filter.field, userField, userVar);
-        if (prismaFilter) {
-          filters.push(prismaFilter);
-        }
-      } else {
-        // Direct field comparison
-        switch (filter.type) {
-          case 'equal':
-            const value = isNaN(filter.value) && filter.value !== 'true' && filter.value !== 'false'
-              ? `'${filter.value}'`
-              : filter.value;
-            filters.push(`{ ${filter.field}: ${value} }`);
-            break;
-          case 'not_equal':
-            filters.push(`{ ${filter.field}: { not: '${filter.value}' } }`);
-            break;
-          case 'is_null':
-            filters.push(`{ ${filter.field}: null }`);
-            break;
-          case 'not_null':
-            filters.push(`{ ${filter.field}: { not: null } }`);
-            break;
-          case 'in':
-            filters.push(`{ ${filter.field}: { in: [${filter.values.join(', ')}] } }`);
-            break;
-        }
-      }
-    }
-
-    // Check if there are role conditions
-    const hasRoleConditions = analysis.conditions && analysis.conditions.some(c =>
-      c.type === 'role_any' || c.type === 'role_equal'
-    );
-
-    // If we have role conditions with OR logic, generate conditional filter
-    const hasOrLogic = analysis.sql && analysis.sql.includes(' OR ');
-    if (hasRoleConditions && hasOrLogic && filters.length > 0) {
-      // Generate: if (roleCheck) return {}; else return filter;
-      const roleConditions = analysis.conditions.filter(c => c.type === 'role_any' || c.type === 'role_equal');
-      const roleChecks = roleConditions.map(c => {
-        if (c.type === 'role_any') {
-          return `[${c.roles.map(r => `'${r}'`).join(', ')}].includes(${userVar}?.role)`;
-        } else if (c.type === 'role_equal') {
-          return `${userVar}?.role === '${c.role}'`;
-        }
-      }).filter(Boolean);
-
-      const roleCheck = roleChecks.length > 1 ? `(${roleChecks.join(' || ')})` : roleChecks[0];
-      const dataFilter = filters.length === 1 ? filters[0] : `{ AND: [${filters.join(', ')}] }`;
-
-      return `if (${roleCheck}) { return {}; } return ${dataFilter};`;
-    }
-
-    if (filters.length === 0) {
-      return '{}';
-    }
-
-    // Deduplicate filters
-    const uniqueFilters = [...new Set(filters)];
-
-    if (uniqueFilters.length === 1) {
-      return uniqueFilters[0];
-    }
-
-    // Check if we need OR or AND
-    if (hasOrLogic) {
-      return `{ OR: [${uniqueFilters.join(', ')}] }`;
-    }
-
-    return `{ AND: [${uniqueFilters.join(', ')}] }`;
-  }
-
-  /**
-   * Build filter for user field comparison (handles relationships)
-   * @param {string} modelName - Current model name
-   * @param {string} fieldName - Field being checked
-   * @param {string} userField - User field to compare against
-   * @param {string} userVar - User variable
-   * @returns {string|null} - Prisma filter or null
-   */
-  buildUserFieldFilter(modelName, fieldName, userField, userVar) {
-    const modelInfo = this.models[modelName];
-    if (!modelInfo) return null;
-
-    // Check if this field exists directly in the model
-    const field = modelInfo.fields[fieldName];
-
-    if (field && !field.isRelation) {
-      // Direct field comparison
-      const userFieldPath = this.convertToUserFieldPath(userField, userVar);
-      return `{ ${fieldName}: ${userFieldPath} }`;
-    }
-
-    // Check if this is a relationship check
-    // For example: checking if course has a student with student_id = user.student?.id
-    const modelRelations = this.relationships[modelName] || {};
-
-    // First pass: Look for junction table relationships (prioritize these)
-    for (const [relationName, relationInfo] of Object.entries(modelRelations)) {
-      const relatedModel = this.models[relationInfo.object];
-      if (!relatedModel) continue;
-
-      // Prioritize many-to-many through junction table
-      // e.g., course -> students (course_student) where student_id = user.student?.id
-      if (relationInfo.fields && relationInfo.fields.length > 1) {
-        // This is a junction table relation
-        // Check if one of the junction fields matches what we're looking for
-        if (relationInfo.fields.includes(fieldName)) {
-          const userFieldPath = this.convertToUserFieldPath(userField, userVar);
-          return this.buildRelationFilter(
-            relationName,
-            relationInfo,
-            fieldName,
-            userFieldPath
-          );
-        }
-      }
-    }
-
-    // Second pass: Look for regular relationships
-    for (const [relationName, relationInfo] of Object.entries(modelRelations)) {
-      const relatedModel = this.models[relationInfo.object];
-      if (!relatedModel) continue;
-
-      // Check if the related model has this field
-      if (relatedModel.fields[fieldName] && !relatedModel.fields[fieldName].isRelation) {
-        // Found it! Build a relation filter
-        const userFieldPath = this.convertToUserFieldPath(userField, userVar);
-        return this.buildRelationFilter(
-          relationName,
-          relationInfo,
-          fieldName,
-          userFieldPath
-        );
-      }
-    }
-
-    // Fallback: direct comparison
-    const userFieldPath = this.convertToUserFieldPath(userField, userVar);
-    return `{ ${fieldName}: ${userFieldPath} }`;
-  }
-
-  /**
-   * Convert user field to proper path
-   * Checks if user model actually has the field before converting to relation path
-   * Examples:
-   *   'id' -> 'user?.id'
-   *   'student_id' (if exists on user) -> 'user?.student_id'
-   *   'student_id' (if NOT exists on user) -> 'user.student?.id'
-   * @param {string} userField - Field name like 'id', 'student_id', 'teacher_id'
-   * @param {string} userVar - User variable name
-   * @returns {string} - Proper user field path
-   */
-  convertToUserFieldPath(userField, userVar) {
-    // Special case for 'id'
-    if (userField === 'id') {
-      return `${userVar}?.id`;
-    }
-
-    // Check if user model actually has this field
-    if (this.userModel && this.userModel.fields) {
-      const userHasField = this.userModel.fields[userField];
-
-      if (userHasField && !userHasField.isRelation) {
-        // User has this field directly - use it
-        return `${userVar}?.${userField}`;
-      }
-    }
-
-    // User doesn't have this field - check if it's a relation pattern
-    if (userField.endsWith('_id')) {
-      // Extract the relation name (e.g., 'student_id' -> 'student')
-      const relationName = userField.slice(0, -3);
-
-      // Check if user has this relation
-      if (this.userModel && this.userModel.fields) {
-        const userHasRelation = this.userModel.fields[relationName];
-        if (userHasRelation && userHasRelation.isRelation) {
-          // User has this relation - use relation path
-          return `${userVar}.${relationName}?.id`;
-        }
-      }
-
-      // Assume it's a relation even if we can't verify
-      return `${userVar}.${relationName}?.id`;
-    }
-
-    // Default: direct field access
-    return `${userVar}?.${userField}`;
-  }
-
-  /**
-   * Build Prisma relation filter
-   * @param {string} relationName - Name of the relation
-   * @param {Object} relationInfo - Relation metadata
-   * @param {string} fieldName - Field to filter on
-   * @param {string} value - Value to compare
-   * @returns {string} - Prisma filter
-   */
-  buildRelationFilter(relationName, relationInfo, fieldName, value) {
-    // Determine if this is a one-to-many or many-to-many
-    const relatedModel = this.models[relationInfo.object];
-
-    if (!relatedModel) {
-      return `{ ${relationName}: { some: { ${fieldName}: ${value} } } }`;
-    }
-
-    // Check if related model is a junction table (has composite key)
-    const isJunctionTable = relationInfo.fields && relationInfo.fields.length > 1;
-
-    if (isJunctionTable) {
-      // Many-to-many through junction
-      // e.g., { students: { some: { student_id: user?.student_id } } }
-      return `{ ${relationName}: { some: { ${fieldName}: ${value} } } }`;
-    }
-
-    // One-to-many or one-to-one
-    // Check if relationName is plural (array) -> use 'some'
-    if (relationName.endsWith('s') || relationInfo.fields) {
-      return `{ ${relationName}: { some: { ${fieldName}: ${value} } } }`;
-    }
-
-    // Singular relation (one-to-one or many-to-one)
-    return `{ ${relationName}: { ${fieldName}: ${value} } }`;
-  }
-
-  /**
-   * Infer relation type from model data
-   * @param {Object} modelInfo - Model information
-   * @param {string} relationName - Relation name
-   * @returns {string} - 'one' | 'many'
-   */
-  inferRelationType(modelInfo, relationName) {
-    if (!modelInfo || !modelInfo.relations) return 'one';
-
-    const relation = modelInfo.relations.find(r => r.name === relationName);
-    return relation && relation.isArray ? 'many' : 'one';
-  }
-
-  /**
-   * Build JavaScript equivalent of Prisma filter (for hasAccess)
-   * @param {string} modelName - The model name
-   * @param {Object} analysis - SQL analysis from DeepSQLAnalyzer
-   * @param {string} dataVar - Data variable name
-   * @param {string} userVar - User variable name
-   * @returns {string} - JavaScript condition
-   */
-  buildJavaScriptCondition(modelName, analysis, dataVar = 'data', userVar = 'user') {
-    const conditions = [];
-    const modelInfo = this.models[modelName];
-
-    for (const filter of analysis.filters) {
-      if (filter.type.startsWith('user_') || filter.type.startsWith('session_')) {
-        const userField = filter.userField || filter.type.replace(/^(user_|session_)/, '');
-
-        // Skip role filters - they're handled in conditions section
-        if (filter.type === 'user_role' || userField === 'role') {
-          continue;
-        }
-
-        const jsCondition = this.buildUserFieldJavaScript(modelName, filter.field, userField, dataVar, userVar);
-        if (jsCondition) {
-          conditions.push(jsCondition);
-        }
-      } else {
-        // Direct field comparison
-        switch (filter.type) {
-          case 'equal':
-            const value = isNaN(filter.value) && filter.value !== 'true' && filter.value !== 'false'
-              ? `'${filter.value}'`
-              : filter.value;
-            conditions.push(`${dataVar}?.${filter.field} === ${value}`);
-            break;
-        }
-      }
-    }
-
-    // Add condition-based checks (roles, etc.)
-    if (analysis.conditions && analysis.conditions.length > 0) {
-      for (const condition of analysis.conditions) {
-        if (condition.javascript) {
-          // Replace user placeholder with actual variable
-          const jsCondition = condition.javascript.replace(/user/g, userVar);
-          conditions.push(jsCondition);
-        } else if (condition.type === 'role_any') {
-          conditions.push(`[${condition.roles.map(r => `'${r}'`).join(', ')}].includes(${userVar}?.role)`);
-        } else if (condition.type === 'role_equal') {
-          conditions.push(`${userVar}?.role === '${condition.role}'`);
-        }
-      }
-    }
-
-    if (conditions.length === 0) return 'true';
-
-    // Deduplicate conditions
-    const uniqueConditions = [...new Set(conditions)];
-
-    if (uniqueConditions.length === 1) return uniqueConditions[0];
-
-    // Check if we need OR or AND
-    const hasOrLogic = analysis.sql && analysis.sql.includes(' OR ');
-    if (hasOrLogic) {
-      return uniqueConditions.join(' || ');
-    }
-
-    return '(' + uniqueConditions.join(' && ') + ')';
-  }
-
-  /**
-   * Build JavaScript condition for user field (handles relations)
-   * @param {string} modelName - Current model name
-   * @param {string} fieldName - Field being checked
-   * @param {string} userField - User field to compare against
-   * @param {string} dataVar - Data variable name
-   * @param {string} userVar - User variable name
-   * @returns {string|null} - JavaScript condition
-   */
-  buildUserFieldJavaScript(modelName, fieldName, userField, dataVar, userVar) {
-    const modelInfo = this.models[modelName];
-    if (!modelInfo) return null;
-
-    // Check if this field exists directly in the model
-    const field = modelInfo.fields[fieldName];
-
-    if (field && !field.isRelation) {
-      // Direct field comparison
-      const userFieldPath = this.convertToUserFieldPath(userField, userVar);
-      return `${dataVar}?.${fieldName} === ${userFieldPath}`;
-    }
-
-    // Field doesn't exist directly - check relationships
-    const modelRelations = this.relationships[modelName] || {};
-
-    // First pass: Look for junction table relationships (prioritize these)
-    for (const [relationName, relationInfo] of Object.entries(modelRelations)) {
-      const relatedModel = this.models[relationInfo.object];
-      if (!relatedModel) continue;
-
-      // Prioritize many-to-many through junction table
-      if (relationInfo.fields && relationInfo.fields.length > 1) {
-        if (relationInfo.fields.includes(fieldName)) {
-          const userFieldPath = this.convertToUserFieldPath(userField, userVar);
-          // Generate: data?.students?.find(s => s.student_id === user.student?.id)
-          return `${dataVar}?.${relationName}?.find(item => item.${fieldName} === ${userFieldPath})`;
-        }
-      }
-    }
-
-    // Second pass: Look for regular relationships
-    for (const [relationName, relationInfo] of Object.entries(modelRelations)) {
-      const relatedModel = this.models[relationInfo.object];
-      if (!relatedModel) continue;
-
-      // Check if the related model has this field
-      if (relatedModel.fields[fieldName] && !relatedModel.fields[fieldName].isRelation) {
-        const userFieldPath = this.convertToUserFieldPath(userField, userVar);
-
-        // Check if this is an array relation (1:n or n:m)
-        if (relationName.endsWith('s') || (relationInfo.fields && relationInfo.fields.length > 1)) {
-          // Use .find() for array relations
-          return `${dataVar}?.${relationName}?.find(item => item.${fieldName} === ${userFieldPath})`;
-        } else {
-          // Singular relation
-          return `${dataVar}?.${relationName}?.${fieldName} === ${userFieldPath}`;
-        }
-      }
-    }
-
-    // Fallback: direct comparison
-    const userFieldPath = this.convertToUserFieldPath(userField, userVar);
-    return `${dataVar}?.${fieldName} === ${userFieldPath}`;
-  }
-}
-
-module.exports = PrismaFilterBuilder;

package/src/parsers/prismaParser.js

@@ -1,287 +0,0 @@
-const fs = require('fs');
-
-/**
- * Extract blocks (model or enum) with proper brace matching
- * @param {string} content - Schema content
- * @param {string} keyword - 'model' or 'enum'
- * @returns {Array} - Array of {name, body} objects
- */
-function extractBlocks(content, keyword) {
-  const blocks = [];
-  const regex = new RegExp(`${keyword}\\s+(\\w+)\\s*{`, 'g');
-  let match;
-
-  while ((match = regex.exec(content)) !== null) {
-    const name = match[1];
-    const startIndex = match.index + match[0].length;
-    let braceCount = 1;
-    let endIndex = startIndex;
-
-    // Find matching closing brace
-    while (braceCount > 0 && endIndex < content.length) {
-      if (content[endIndex] === '{') braceCount++;
-      if (content[endIndex] === '}') braceCount--;
-      endIndex++;
-    }
-
-    const body = content.substring(startIndex, endIndex - 1);
-    blocks.push({ name, body });
-  }
-
-  return blocks;
-}
-
-/**
- * Parse Prisma schema file and extract model information
- * @param {string} schemaPath - Path to Prisma schema file
- * @returns {Object} - Object containing models and their fields
- */
-function parsePrismaSchema(schemaPath) {
-  const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
-  const models = {};
-
-  // Extract models with proper brace matching
-  const modelBlocks = extractBlocks(schemaContent, 'model');
-  for (const { name, body } of modelBlocks) {
-    const fields = parseModelFields(body);
-    const compositeKeyFields = parseCompositeKey(body);
-    const dbName = parseMapDirective(body);
-
-    // Mark composite key fields with isId
-    if (compositeKeyFields) {
-      for (const fieldName of compositeKeyFields) {
-        if (fields[fieldName]) {
-          fields[fieldName].isId = true;
-        }
-      }
-    }
-
-    models[name] = {
-      name,
-      fields,
-      relations: parseModelRelations(body),
-      compositeKey: compositeKeyFields,
-      dbName: dbName || name.toLowerCase() // Default to lowercase model name
-    };
-  }
-
-  // Extract enums
-  const enums = {};
-  const enumBlocks = extractBlocks(schemaContent, 'enum');
-  for (const { name, body } of enumBlocks) {
-    enums[name] = parseEnumValues(body);
-  }
-
-  return { models, enums };
-}
-
-/**
- * Parse composite key from @@id directive
- * @param {string} modelBody - The content inside model braces
- * @returns {Array|null} - Array of field names in composite key, or null
- */
-function parseCompositeKey(modelBody) {
-  const lines = modelBody.split('\n').map(line => line.trim());
-
-  for (const line of lines) {
-    // Match @@id([field1, field2, ...])
-    const match = line.match(/^@@id\(\[([^\]]+)\]\)/);
-    if (match) {
-      const fieldsStr = match[1];
-      return fieldsStr.split(',').map(f => f.trim());
-    }
-  }
-
-  return null;
-}
-
-/**
- * Parse @@map directive to get database table name
- * @param {string} modelBody - The content inside model braces
- * @returns {string|null} - Database table name, or null if no @@map directive
- */
-function parseMapDirective(modelBody) {
-  const lines = modelBody.split('\n').map(line => line.trim());
-
-  for (const line of lines) {
-    // Match @@map("table_name") or @@map('table_name')
-    const match = line.match(/^@@map\(["']([^"']+)["']\)/);
-    if (match) {
-      return match[1];
-    }
-  }
-
-  return null;
-}
-
-/**
- * Parse model fields from model body
- * @param {string} modelBody - The content inside model braces
- * @returns {Object} - Field definitions
- */
-function parseModelFields(modelBody) {
-  const fields = {};
-  const lines = modelBody.split('\n').map(line => line.trim()).filter(line => line && !line.startsWith('@@'));
-
-  for (const line of lines) {
-    // Skip relation fields and index definitions
-    if (line.startsWith('//') || line.startsWith('@@')) continue;
-
-    // Match field definition: fieldName Type modifiers
-    const fieldMatch = line.match(/^(\w+)\s+(\w+)(\?|\[\])?\s*(.*)?$/);
-    if (fieldMatch) {
-      const [, fieldName, fieldType, modifier, attributes] = fieldMatch;
-
-      // Determine if it's a relation field (starts with uppercase)
-      const isRelation = fieldType[0] === fieldType[0].toUpperCase() &&
-                        !['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Decimal', 'Json', 'Bytes'].includes(fieldType);
-
-      fields[fieldName] = {
-        type: fieldType,
-        optional: modifier === '?',
-        isArray: modifier === '[]',
-        isRelation: isRelation,
-        attributes: attributes || ''
-      };
-    }
-  }
-
-  return fields;
-}
-
-/**
- * Parse model relations
- * @param {string} modelBody - The content inside model braces
- * @returns {Array} - Array of relation definitions
- */
-function parseModelRelations(modelBody) {
-  const relations = [];
-  const lines = modelBody.split('\n').map(line => line.trim()).filter(line => line);
-
-  for (const line of lines) {
-    if (line.startsWith('//') || line.startsWith('@@')) continue;
-
-    const fieldMatch = line.match(/^(\w+)\s+(\w+)(\?|\[\])?\s*(.*)?$/);
-    if (fieldMatch) {
-      const [, fieldName, fieldType, modifier, attributes] = fieldMatch;
-
-      // Check if it's a relation (not a Prisma scalar type)
-      const scalarTypes = ['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Decimal', 'Json', 'Bytes', 'BigInt'];
-      const isRelation = !scalarTypes.includes(fieldType);
-
-      if (isRelation) {
-        relations.push({
-          name: fieldName,
-          type: fieldType,
-          isArray: modifier === '[]',
-          optional: modifier === '?'
-        });
-      }
-    }
-  }
-
-  return relations;
-}
-
-/**
- * Parse enum values
- * @param {string} enumBody - The content inside enum braces
- * @returns {Array} - Array of enum values
- */
-function parseEnumValues(enumBody) {
-  const values = [];
-  const lines = enumBody.split('\n').map(line => line.trim()).filter(line => line && !line.startsWith('//'));
-
-  for (const line of lines) {
-    const valueMatch = line.match(/^(\w+)/);
-    if (valueMatch) {
-      values.push(valueMatch[1]);
-    }
-  }
-
-  return values;
-}
-
-/**
- * Use Prisma's DMMF (Data Model Meta Format) to get model information
- * This is an alternative approach that uses Prisma's own abstraction
- * In Prisma 7, we use getDMMF from @prisma/internals instead of accessing it from the client
- * @param {string} schemaPath - Path to Prisma schema file
- * @returns {Object} - Models extracted from DMMF
- */
-async function parsePrismaDMMF(schemaPath) {
-  try {
-    // In Prisma 7, DMMF is no longer exposed on the client
-    // We need to use getDMMF from @prisma/internals instead
-    const { getDMMF } = require('@prisma/internals');
-    const fs = require('fs');
-
-    // Read the schema file
-    const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
-
-    // Get DMMF from the schema
-    const dmmf = await getDMMF({
-      datamodel: schemaContent
-    });
-
-    const models = {};
-
-    for (const model of dmmf.datamodel.models) {
-      // Extract composite key if present
-      const compositeKey = model.primaryKey && model.primaryKey.fields && model.primaryKey.fields.length > 1
-        ? model.primaryKey.fields
-        : null;
-
-      models[model.name] = {
-        name: model.name,
-        fields: {},
-        relations: [],
-        compositeKey,
-        dbName: model.dbName || model.name.toLowerCase() // Use dbName from DMMF or default to lowercase
-      };
-
-      for (const field of model.fields) {
-        models[model.name].fields[field.name] = {
-          type: field.type,
-          optional: !field.isRequired,
-          isArray: field.isList,
-          isRelation: field.kind === 'object',
-          isId: field.isId || false,
-          isUnique: field.isUnique || false,
-          isUpdatedAt: field.isUpdatedAt || false,
-          hasDefaultValue: field.hasDefaultValue || false
-        };
-
-        if (field.kind === 'object') {
-          models[model.name].relations.push({
-            name: field.name,
-            type: field.type,
-            isArray: field.isList,
-            optional: !field.isRequired,
-            relationName: field.relationName,
-            relationFromFields: field.relationFromFields || [],
-            relationToFields: field.relationToFields || [],
-            kind: field.kind
-          });
-
-          // Also add these to the field object for consistency
-          models[model.name].fields[field.name].relationName = field.relationName;
-          models[model.name].fields[field.name].relationFromFields = field.relationFromFields || [];
-          models[model.name].fields[field.name].relationToFields = field.relationToFields || [];
-          models[model.name].fields[field.name].kind = field.kind;
-        }
-      }
-    }
-
-    return { models, enums: dmmf.datamodel.enums };
-  } catch (error) {
-    console.warn('Could not use getDMMF from @prisma/internals, falling back to schema parsing');
-    console.warn('Error:', error.message);
-    return null;
-  }
-}
-
-module.exports = {
-  parsePrismaSchema,
-  parsePrismaDMMF
-};