@withtruing/companion 0.0.0-stage → 0.13.0

package/dist/schema-entities.js

@@ -0,0 +1,755 @@
+import spawn from 'cross-spawn';
+import ts from 'typescript';
+const MAX_FILE_BYTES = 1_048_576;
+const MAX_SCHEMA_ENTITIES = 1_000;
+const MAX_MODULES = 1_000;
+const MAX_NAME_LENGTH = 200;
+const GIT_TIMEOUT_MS = 60_000;
+const HUB_MODULE_THRESHOLD = 4;
+const safePath = (path) => typeof path === 'string'
+    && path.length > 0
+    && !path.startsWith('/')
+    && !path.includes('\\')
+    && !/^[A-Za-z]:/.test(path)
+    && path.split('/').every((segment) => segment.length > 0 && segment !== '.' && segment !== '..');
+export function validSchemaProbe(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const probe = value;
+    if (Object.keys(probe).sort().join('\0') !== ['migrationGlobs', 'modules', 'schemaPaths'].sort().join('\0')
+        || !Array.isArray(probe.schemaPaths) || !Array.isArray(probe.migrationGlobs) || !Array.isArray(probe.modules)
+        || probe.schemaPaths.length > 3_000 || probe.migrationGlobs.length > 100 || probe.modules.length > MAX_MODULES
+        || probe.schemaPaths.some((path) => !safePath(path) || !String(path).endsWith('.prisma'))
+        || probe.migrationGlobs.some((glob) => typeof glob !== 'string' || !glob || glob.length > 500))
+        return false;
+    const moduleIds = new Set();
+    for (const entry of probe.modules) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return false;
+        const module = entry;
+        if (Object.keys(module).sort().join('\0') !== ['moduleId', 'paths'].sort().join('\0')
+            || typeof module.moduleId !== 'string' || !module.moduleId || module.moduleId.length > MAX_NAME_LENGTH
+            || moduleIds.has(module.moduleId) || !Array.isArray(module.paths) || module.paths.length > 3_000
+            || module.paths.some((path) => !safePath(path)))
+            return false;
+        moduleIds.add(module.moduleId);
+    }
+    return new Set(probe.schemaPaths).size === probe.schemaPaths.length;
+}
+function runGit(repoPath, args, outputLimit = MAX_FILE_BYTES + 1) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', ['--no-replace-objects', ...args], {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            windowsHide: true,
+        });
+        const chunks = [];
+        let bytes = 0;
+        let settled = false;
+        const finish = (error, output) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve(output);
+        };
+        child.stdout?.on('data', (chunk) => {
+            bytes += chunk.length;
+            if (bytes > outputLimit) {
+                child.kill('SIGKILL');
+                finish(new Error('git output exceeded limit'));
+            }
+            else
+                chunks.push(chunk);
+        });
+        child.stderr?.on('data', () => undefined);
+        child.on('error', (error) => finish(error));
+        child.on('close', (code, signal) => {
+            if (signal || code === null)
+                finish(new Error('git command failed'));
+            else
+                finish(undefined, { stdout: Buffer.concat(chunks), exitCode: code });
+        });
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+            finish(new Error('git command timed out'));
+        }, GIT_TIMEOUT_MS);
+    });
+}
+async function gitText(repoPath, revision, path) {
+    const output = await runGit(repoPath, ['show', `${revision}:${path}`]);
+    if (output.exitCode !== 0)
+        return null;
+    if (output.stdout.includes(0))
+        return null;
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(output.stdout);
+    }
+    catch {
+        return null;
+    }
+}
+async function gitPathExists(repoPath, revision, path) {
+    return (await runGit(repoPath, ['cat-file', '-e', `${revision}:${path}`], 100)).exitCode === 0;
+}
+function skipTrivia(source, start) {
+    let index = start;
+    while (index < source.length) {
+        if (/\s/.test(source[index]))
+            index += 1;
+        else if (source.startsWith('//', index)) {
+            const end = source.indexOf('\n', index + 2);
+            index = end === -1 ? source.length : end + 1;
+        }
+        else if (source.startsWith('/*', index)) {
+            const end = source.indexOf('*/', index + 2);
+            if (end === -1)
+                return -1;
+            index = end + 2;
+        }
+        else
+            break;
+    }
+    return index;
+}
+function findBlockEnd(source, open) {
+    let depth = 0;
+    let quote = null;
+    for (let index = open; index < source.length; index += 1) {
+        const char = source[index];
+        if (quote) {
+            if (char === '\\')
+                index += 1;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (source.startsWith('//', index)) {
+            const end = source.indexOf('\n', index + 2);
+            if (end === -1)
+                return -1;
+            index = end;
+        }
+        else if (source.startsWith('/*', index)) {
+            const end = source.indexOf('*/', index + 2);
+            if (end === -1)
+                return -1;
+            index = end + 1;
+        }
+        else if (char === '{')
+            depth += 1;
+        else if (char === '}' && --depth === 0)
+            return index;
+    }
+    return -1;
+}
+function canonicalPrisma(text) {
+    let output = '';
+    let quote = null;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (quote) {
+            output += char;
+            if (char === '\\' && index + 1 < text.length)
+                output += text[++index];
+            else if (char === quote)
+                quote = null;
+        }
+        else if (char === '"' || char === "'") {
+            quote = char;
+            output += char;
+        }
+        else if (text.startsWith('//', index)) {
+            const end = text.indexOf('\n', index + 2);
+            if (end === -1)
+                break;
+            index = end;
+        }
+        else if (text.startsWith('/*', index)) {
+            const end = text.indexOf('*/', index + 2);
+            if (end === -1)
+                return null;
+            index = end + 1;
+        }
+        else if (!/\s/.test(char))
+            output += char;
+    }
+    return quote ? null : output;
+}
+function modelMappedName(text) {
+    const occurrences = [...text.matchAll(/@@map\b/g)];
+    if (occurrences.length === 0)
+        return null;
+    if (occurrences.length !== 1)
+        return undefined;
+    const match = /@@map\s*\(\s*("(?:\\.|[^"\\])*")\s*\)/.exec(text);
+    if (!match)
+        return undefined;
+    try {
+        const value = JSON.parse(match[1]);
+        return typeof value === 'string' && value ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parsePrismaSchema(source) {
+    const blocks = new Map();
+    const blockKinds = new Set(['model', 'enum', 'view', 'type', 'datasource', 'generator']);
+    let index = 0;
+    while (index < source.length) {
+        index = skipTrivia(source, index);
+        if (index < 0)
+            return null;
+        if (index >= source.length)
+            break;
+        const word = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(index));
+        if (!word) {
+            if (source[index] === '{' || source[index] === '}')
+                return null;
+            index += 1;
+            continue;
+        }
+        const kind = word[0];
+        index += word[0].length;
+        if (!blockKinds.has(kind))
+            continue;
+        index = skipTrivia(source, index);
+        if (index < 0)
+            return null;
+        const nameMatch = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(index));
+        if (!nameMatch)
+            return null;
+        const name = nameMatch[0];
+        index += name.length;
+        index = skipTrivia(source, index);
+        if (index < 0 || source[index] !== '{')
+            return null;
+        const end = findBlockEnd(source, index);
+        if (end < 0)
+            return null;
+        const text = source.slice(index, end + 1);
+        const canonical = canonicalPrisma(text);
+        if (canonical === null)
+            return null;
+        const mappedName = kind === 'model' ? modelMappedName(canonical) : null;
+        if (mappedName === undefined)
+            return null;
+        const key = `${kind}:${name}`;
+        if (blocks.has(key))
+            return null;
+        blocks.set(key, { kind, name, text, canonical, mappedName });
+        index = end + 1;
+    }
+    return { blocks };
+}
+function modelStatements(text) {
+    const open = text.indexOf('{');
+    const close = text.lastIndexOf('}');
+    if (open < 0 || close <= open)
+        return null;
+    const statements = [];
+    let current = '';
+    let quote = null;
+    let depth = 0;
+    for (let index = open + 1; index < close; index += 1) {
+        const char = text[index];
+        if (quote) {
+            current += char;
+            if (char === '\\' && index + 1 < close)
+                current += text[++index];
+            else if (char === quote)
+                quote = null;
+        }
+        else if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+        }
+        else if (text.startsWith('//', index)) {
+            const end = text.indexOf('\n', index + 2);
+            index = end === -1 || end >= close ? close - 1 : end - 1;
+        }
+        else if (text.startsWith('/*', index)) {
+            const end = text.indexOf('*/', index + 2);
+            if (end === -1 || end >= close)
+                return null;
+            index = end + 1;
+        }
+        else if (char === '(' || char === '[') {
+            depth += 1;
+            current += char;
+        }
+        else if (char === ')' || char === ']') {
+            if (depth === 0)
+                return null;
+            depth -= 1;
+            current += char;
+        }
+        else if ((char === '\n' || char === '\r') && depth === 0) {
+            if (current.trim())
+                statements.push(current.trim());
+            current = '';
+        }
+        else
+            current += char;
+    }
+    if (quote || depth !== 0)
+        return null;
+    if (current.trim())
+        statements.push(current.trim());
+    return statements;
+}
+function canonicalAttributes(source, prefix) {
+    const attributes = [];
+    let index = 0;
+    while (index < source.length) {
+        while (/\s/.test(source[index] ?? ''))
+            index += 1;
+        if (!source.startsWith(prefix, index) || (prefix === '@' && source[index + 1] === '@'))
+            return null;
+        const start = index;
+        index += prefix.length;
+        const name = /^[A-Za-z_][A-Za-z0-9_.]*/.exec(source.slice(index));
+        if (!name)
+            return null;
+        index += name[0].length;
+        while (/\s/.test(source[index] ?? ''))
+            index += 1;
+        if (source[index] === '(') {
+            let depth = 0;
+            let quote = null;
+            for (; index < source.length; index += 1) {
+                const char = source[index];
+                if (quote) {
+                    if (char === '\\')
+                        index += 1;
+                    else if (char === quote)
+                        quote = null;
+                }
+                else if (char === '"' || char === "'")
+                    quote = char;
+                else if (char === '(')
+                    depth += 1;
+                else if (char === ')' && --depth === 0) {
+                    index += 1;
+                    break;
+                }
+            }
+            if (depth !== 0 || quote)
+                return null;
+        }
+        const canonical = canonicalPrisma(source.slice(start, index));
+        if (canonical === null)
+            return null;
+        attributes.push(canonical);
+    }
+    return attributes;
+}
+function comparableModel(block, modelNames) {
+    const statements = modelStatements(block.text);
+    if (!statements)
+        return null;
+    const fields = [];
+    const blockAttributes = [];
+    for (const statement of statements) {
+        if (statement.startsWith('@@')) {
+            const attributes = canonicalAttributes(statement, '@@');
+            if (!attributes)
+                return null;
+            blockAttributes.push(...attributes);
+            continue;
+        }
+        const field = /^([A-Za-z_][A-Za-z0-9_]*)\s+([A-Za-z_][A-Za-z0-9_]*)(\[\]|\?)?\s*(.*)$/s.exec(statement);
+        if (!field)
+            return null;
+        const [, name, type, modifier = '', rest] = field;
+        const attributes = canonicalAttributes(rest, '@');
+        if (!attributes)
+            return null;
+        if (modelNames.has(type))
+            continue;
+        fields.push(`${name}:${type}${modifier}:${attributes.sort().join(',')}`);
+    }
+    return `${fields.join('|')}#${blockAttributes.sort().join(',')}`;
+}
+function modelsUsingEnums(schemas, enumNames) {
+    const models = [];
+    for (const schema of schemas) {
+        for (const block of schema.blocks.values()) {
+            if (block.kind !== 'model')
+                continue;
+            const statements = modelStatements(block.text);
+            if (!statements)
+                return null;
+            for (const statement of statements) {
+                if (statement.startsWith('@@'))
+                    continue;
+                const field = /^[A-Za-z_][A-Za-z0-9_]*\s+([A-Za-z_][A-Za-z0-9_]*)(?:\[\]|\?)?(?:\s|$)/s.exec(statement);
+                if (!field)
+                    continue;
+                if (enumNames.has(field[1])) {
+                    models.push(block);
+                    break;
+                }
+            }
+        }
+    }
+    return models;
+}
+function changedBlocks(before, after) {
+    for (const kind of ['datasource', 'generator']) {
+        const keys = new Set([...before.blocks.keys(), ...after.blocks.keys()].filter((key) => key.startsWith(`${kind}:`)));
+        for (const key of keys)
+            if (before.blocks.get(key)?.canonical !== after.blocks.get(key)?.canonical)
+                return null;
+    }
+    const changed = [];
+    const modelNames = new Set([...before.blocks.values(), ...after.blocks.values()]
+        .filter((block) => block.kind === 'model').map((block) => block.name));
+    const keys = new Set([...before.blocks.keys(), ...after.blocks.keys()]);
+    for (const key of keys) {
+        const prior = before.blocks.get(key);
+        const next = after.blocks.get(key);
+        if (prior?.kind === 'datasource' || prior?.kind === 'generator'
+            || next?.kind === 'datasource' || next?.kind === 'generator')
+            continue;
+        if (!prior || !next) {
+            changed.push(next ?? prior);
+            continue;
+        }
+        if (prior.kind === 'model' && next.kind === 'model') {
+            const priorComparable = comparableModel(prior, modelNames);
+            const nextComparable = comparableModel(next, modelNames);
+            if (priorComparable === null || nextComparable === null) {
+                if (prior.canonical !== next.canonical)
+                    changed.push(next);
+            }
+            else if (priorComparable !== nextComparable)
+                changed.push(next);
+        }
+        else if (prior.canonical !== next.canonical)
+            changed.push(next);
+    }
+    return changed;
+}
+function migrationPath(path, globs) {
+    return globs.some((glob) => glob === '**/migrations/**/*.sql'
+        ? /(^|\/)migrations\/.*\.sql$/i.test(path)
+        : glob === '*.sql' ? path.endsWith('.sql') : false);
+}
+function splitSql(source) {
+    if (/\$[A-Za-z0-9_]*\$/.test(source))
+        return null;
+    const statements = [];
+    let current = '';
+    let quote = null;
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        if (quote) {
+            current += char;
+            if (char === quote) {
+                if (source[index + 1] === quote)
+                    current += source[++index];
+                else
+                    quote = null;
+            }
+            else if (char === '\\' && quote === "'" && index + 1 < source.length)
+                current += source[++index];
+        }
+        else if (char === "'" || char === '"' || char === '`') {
+            quote = char;
+            current += char;
+        }
+        else if (source.startsWith('--', index)) {
+            const end = source.indexOf('\n', index + 2);
+            index = end === -1 ? source.length : end;
+            current += ' ';
+        }
+        else if (source.startsWith('/*', index)) {
+            const end = source.indexOf('*/', index + 2);
+            if (end === -1)
+                return null;
+            index = end + 1;
+            current += ' ';
+        }
+        else if (char === ';') {
+            if (current.trim())
+                statements.push(current.trim());
+            current = '';
+        }
+        else
+            current += char;
+    }
+    if (quote)
+        return null;
+    if (current.trim())
+        statements.push(current.trim());
+    return statements;
+}
+const IDENTIFIER = '(?:"(?:[^"]|"")+"|`(?:[^`]|``)+`|[A-Za-z_][A-Za-z0-9_$]*)';
+const QUALIFIED = `(${IDENTIFIER}(?:\\s*\\.\\s*${IDENTIFIER})*)`;
+function identifierName(value) {
+    const last = value.split('.').at(-1).trim();
+    if (last.startsWith('"'))
+        return last.slice(1, -1).replaceAll('""', '"');
+    if (last.startsWith('`'))
+        return last.slice(1, -1).replaceAll('``', '`');
+    return last;
+}
+function sqlTargets(source) {
+    const statements = splitSql(source);
+    if (!statements)
+        return null;
+    const targets = [];
+    const patterns = [
+        { kind: 'table', pattern: new RegExp(`^CREATE\\s+TABLE(?:\\s+IF\\s+NOT\\s+EXISTS)?\\s+${QUALIFIED}`, 'i') },
+        { kind: 'table', pattern: new RegExp(`^ALTER\\s+TABLE(?:\\s+ONLY)?\\s+${QUALIFIED}`, 'i') },
+        { kind: 'table', pattern: new RegExp(`^DROP\\s+TABLE(?:\\s+IF\\s+EXISTS)?\\s+${QUALIFIED}`, 'i') },
+        { kind: 'table', pattern: new RegExp(`^CREATE\\s+(?:UNIQUE\\s+)?INDEX(?:\\s+CONCURRENTLY)?(?:\\s+IF\\s+NOT\\s+EXISTS)?\\s+${IDENTIFIER}\\s+ON\\s+(?:ONLY\\s+)?${QUALIFIED}`, 'i') },
+        { kind: 'enum', pattern: new RegExp(`^ALTER\\s+TYPE\\s+${QUALIFIED}`, 'i') },
+        { kind: 'enum', pattern: new RegExp(`^CREATE\\s+TYPE\\s+${QUALIFIED}`, 'i') },
+    ];
+    for (const statement of statements) {
+        let matched = false;
+        for (const { kind, pattern } of patterns) {
+            const match = pattern.exec(statement);
+            if (!match)
+                continue;
+            targets.push({ kind, name: identifierName(match[1]) });
+            matched = true;
+            break;
+        }
+        if (!matched && !/^(?:BEGIN|COMMIT|ROLLBACK|DROP\s+INDEX\b|SET\s+|UPDATE\s+|INSERT\s+INTO\s+|DELETE\s+FROM\s+)/i.test(statement))
+            return null;
+    }
+    return targets;
+}
+const lowerCamel = (name) => name ? `${name[0].toLowerCase()}${name.slice(1)}` : name;
+function termsFor(block) {
+    return {
+        name: block.name,
+        kind: block.kind,
+        accessor: block.kind === 'model' || block.kind === 'view' ? lowerCamel(block.name) : null,
+        mappedName: block.mappedName,
+    };
+}
+function mappedEntity(target, schemas) {
+    const kinds = target.kind === 'table' ? new Set(['model', 'view']) : new Set(['enum']);
+    const candidates = schemas.flatMap((schema) => [...schema.blocks.values()]).filter((block) => kinds.has(block.kind) && (block.mappedName === target.name || block.name === target.name));
+    if (candidates.length === 1)
+        return candidates[0];
+    return null;
+}
+function referenceFacts(path, text) {
+    const facts = {
+        calledAccessors: new Set(),
+        importedNames: new Set(),
+        prismaNames: new Set(),
+        enumNames: new Set(),
+        strings: [],
+    };
+    if (path.toLowerCase().endsWith('.sql'))
+        facts.strings.push(text);
+    const kind = path.endsWith('.tsx') ? ts.ScriptKind.TSX
+        : path.endsWith('.jsx') ? ts.ScriptKind.JSX
+            : path.endsWith('.js') || path.endsWith('.mjs') || path.endsWith('.cjs') ? ts.ScriptKind.JS
+                : ts.ScriptKind.TS;
+    const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, kind);
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)
+            && (node.moduleSpecifier.text === '@prisma/client' || node.moduleSpecifier.text.includes('.prisma/client'))
+            && node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+            for (const element of node.importClause.namedBindings.elements) {
+                facts.importedNames.add((element.propertyName ?? element.name).text);
+            }
+        }
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)
+            && ts.isPropertyAccessExpression(node.expression.expression)) {
+            facts.calledAccessors.add(node.expression.expression.name.text);
+        }
+        if (ts.isQualifiedName(node) && ts.isIdentifier(node.left)) {
+            if (node.left.text === 'Prisma')
+                facts.prismaNames.add(node.right.text);
+            else if (node.left.text === '$Enums')
+                facts.enumNames.add(node.right.text);
+        }
+        else if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+            if (node.expression.text === 'Prisma')
+                facts.prismaNames.add(node.name.text);
+            else if (node.expression.text === '$Enums')
+                facts.enumNames.add(node.name.text);
+            else
+                facts.enumNames.add(node.expression.text);
+        }
+        if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+            || ts.isTemplateHead(node) || ts.isTemplateMiddle(node) || ts.isTemplateTail(node)) {
+            facts.strings.push(node.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return facts;
+}
+function generatedTypeReference(names, model) {
+    const suffix = /^(?:Where|Select|Omit|Include|GetPayload|DefaultArgs|FieldRefs|Scalar|Nullable|ListRelation|Relation|Create|Update|Unchecked|OrderBy|Find|Aggregate|GroupBy|Count|Min|Max|Avg|Sum|Delegate|Payload|Args|Result)/;
+    for (const name of names) {
+        if (name.startsWith(model) && suffix.test(name.slice(model.length)))
+            return true;
+    }
+    return false;
+}
+function referencesEntity(facts, entity) {
+    if (facts.importedNames.has(entity.name))
+        return true;
+    if (entity.kind === 'enum') {
+        return facts.enumNames.has(entity.name);
+    }
+    if (entity.accessor && facts.calledAccessors.has(entity.accessor))
+        return true;
+    if (generatedTypeReference(facts.prismaNames, entity.name))
+        return true;
+    return entity.mappedName !== null
+        && facts.strings.some((value) => value.includes(`"${entity.mappedName}"`));
+}
+async function headFile(repoPath, head, path) {
+    const size = await runGit(repoPath, ['cat-file', '-s', `${head}:${path}`], 100);
+    if (size.exitCode !== 0)
+        return null;
+    const parsed = Number(size.stdout.toString('ascii').trim());
+    if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > MAX_FILE_BYTES)
+        return null;
+    return gitText(repoPath, head, path);
+}
+export async function detectSchemaImpact(input) {
+    if (!validSchemaProbe(input.probe))
+        return { entities: null, modulesReferencing: [] };
+    const changedSchemas = input.changedPaths.filter((path) => path.endsWith('.prisma'));
+    const changedMigrations = input.changedPaths.filter((path) => migrationPath(path, input.probe.migrationGlobs));
+    if (changedSchemas.length === 0 && changedMigrations.length === 0) {
+        return { entities: [], modulesReferencing: [] };
+    }
+    try {
+        const entityByName = new Map();
+        const headSchemas = [];
+        const baseSchemas = [];
+        for (const path of new Set([...input.probe.schemaPaths, ...changedSchemas])) {
+            const text = await gitText(input.repoPath, input.head, path);
+            if (text === null) {
+                if (await gitPathExists(input.repoPath, input.head, path)) {
+                    return { entities: null, modulesReferencing: [] };
+                }
+                continue;
+            }
+            const parsed = parsePrismaSchema(text);
+            if (!parsed)
+                return { entities: null, modulesReferencing: [] };
+            headSchemas.push(parsed);
+        }
+        for (const path of changedSchemas) {
+            const [beforeText, afterText] = await Promise.all([
+                gitText(input.repoPath, input.base, path),
+                gitText(input.repoPath, input.head, path),
+            ]);
+            const [beforeExists, afterExists] = await Promise.all([
+                beforeText === null ? gitPathExists(input.repoPath, input.base, path) : false,
+                afterText === null ? gitPathExists(input.repoPath, input.head, path) : false,
+            ]);
+            if (beforeExists || afterExists)
+                return { entities: null, modulesReferencing: [] };
+            const before = beforeText === null ? { blocks: new Map() } : parsePrismaSchema(beforeText);
+            const after = afterText === null ? { blocks: new Map() } : parsePrismaSchema(afterText);
+            if (!before || !after)
+                return { entities: null, modulesReferencing: [] };
+            baseSchemas.push(before);
+            const changed = changedBlocks(before, after);
+            if (!changed)
+                return { entities: null, modulesReferencing: [] };
+            for (const block of changed) {
+                const terms = termsFor(block);
+                entityByName.set(terms.name, terms);
+            }
+        }
+        for (const path of changedMigrations) {
+            const sql = await gitText(input.repoPath, input.head, path);
+            if (sql === null) {
+                if (await gitPathExists(input.repoPath, input.head, path)) {
+                    return { entities: null, modulesReferencing: [] };
+                }
+                continue;
+            }
+            const targets = sqlTargets(sql);
+            if (!targets)
+                return { entities: null, modulesReferencing: [] };
+            for (const target of targets) {
+                const block = mappedEntity(target, headSchemas);
+                if (!block)
+                    return { entities: null, modulesReferencing: [] };
+                const terms = termsFor(block);
+                entityByName.set(terms.name, terms);
+            }
+        }
+        const changedEnums = new Set([...entityByName.values()]
+            .filter((entity) => entity.kind === 'enum').map((entity) => entity.name));
+        if (changedEnums.size > 0) {
+            const headModels = modelsUsingEnums(headSchemas, changedEnums);
+            const baseModels = modelsUsingEnums(baseSchemas, changedEnums);
+            if (!headModels || !baseModels)
+                return { entities: null, modulesReferencing: [] };
+            for (const block of [...headModels, ...baseModels]) {
+                if (!entityByName.has(block.name))
+                    entityByName.set(block.name, termsFor(block));
+            }
+        }
+        const entities = [...entityByName.keys()].sort((left, right) => left.localeCompare(right));
+        if (entities.length > MAX_SCHEMA_ENTITIES || entities.some((name) => !name || name.length > MAX_NAME_LENGTH)) {
+            return { entities: null, modulesReferencing: [] };
+        }
+        if (entities.length === 0)
+            return { entities, modulesReferencing: [] };
+        const excluded = (path) => path.endsWith('.prisma') || migrationPath(path, input.probe.migrationGlobs);
+        const pathModuleCounts = new Map();
+        for (const module of input.probe.modules) {
+            for (const path of new Set(module.paths))
+                pathModuleCounts.set(path, (pathModuleCounts.get(path) ?? 0) + 1);
+        }
+        const referenceEntities = [...entityByName.values()];
+        const fileCache = new Map();
+        const readHeadFile = (path) => {
+            let pending = fileCache.get(path);
+            if (!pending) {
+                pending = headFile(input.repoPath, input.head, path)
+                    .then((text) => text === null ? null : referenceFacts(path, text));
+                fileCache.set(path, pending);
+            }
+            return pending;
+        };
+        const modulesReferencing = [];
+        for (const module of input.probe.modules) {
+            let referenced = false;
+            for (const path of module.paths) {
+                if (excluded(path) || (pathModuleCounts.get(path) ?? 0) > HUB_MODULE_THRESHOLD)
+                    continue;
+                const facts = await readHeadFile(path);
+                if (facts === null)
+                    continue;
+                if (referenceEntities.some((entity) => referencesEntity(facts, entity))) {
+                    referenced = true;
+                    break;
+                }
+            }
+            if (referenced)
+                modulesReferencing.push(module.moduleId);
+        }
+        modulesReferencing.sort((left, right) => left.localeCompare(right));
+        return { entities, modulesReferencing };
+    }
+    catch {
+        return { entities: null, modulesReferencing: [] };
+    }
+}