137 lines
5.1 KiB
JavaScript
137 lines
5.1 KiB
JavaScript
import { readdirSync, readFileSync, statSync } from 'node:fs';
|
|
import { dirname, isAbsolute, relative, resolve } from 'node:path';
|
|
|
|
const SDK_ALLOWED = /framework[\\/]sdk(?:[\\/]|$)/;
|
|
const FRAMEWORK_INTERNAL = /framework[\\/](?:net|protocol|platform|application|domain|presentation|ui|core|compat)(?:[\\/]|$)/;
|
|
const LEGACY_RUNTIME = /framework[\\/](?:net[\\/]net-client|platform[\\/](?:session|startup|room-rpc-bus|readonly|stores[\\/](?:app-store|player-store|room-store|types))|protocol[\\/]room-handlers)\.ts$/;
|
|
const CONTRACTS_PATH = /framework[\\/]sdk[\\/]contracts(?:[\\/]|$)/;
|
|
const MIGRATION_ONLY_NAMES = new Set(['GameContext', 'IGameModule']);
|
|
|
|
/**
|
|
* Recursively scans TypeScript imports for framework/game layering violations.
|
|
* Paths in violations are normalized for useful, cross-platform diagnostics.
|
|
*/
|
|
export function scanImportBoundaries(options) {
|
|
const frameworkDir = resolve(options.frameworkDir);
|
|
const gamesDir = resolve(options.gamesDir);
|
|
const violations = [];
|
|
|
|
for (const file of [...typescriptFiles(frameworkDir), ...typescriptFiles(gamesDir)]) {
|
|
const source = readFileSync(file, 'utf8');
|
|
for (const imported of extractImports(source)) {
|
|
const resolved = imported.specifier.startsWith('.')
|
|
? resolve(dirname(file), imported.specifier)
|
|
: null;
|
|
const violation = findViolation({
|
|
file,
|
|
specifier: imported.specifier,
|
|
bindings: imported.bindings,
|
|
resolved,
|
|
frameworkDir,
|
|
gamesDir,
|
|
});
|
|
if (violation) violations.push(violation);
|
|
}
|
|
}
|
|
|
|
return violations;
|
|
}
|
|
|
|
function* typescriptFiles(directory) {
|
|
let entries;
|
|
try {
|
|
entries = readdirSync(directory);
|
|
} catch (error) {
|
|
if (error && error.code === 'ENOENT') return;
|
|
throw error;
|
|
}
|
|
for (const entry of entries) {
|
|
const file = resolve(directory, entry);
|
|
if (statSync(file).isDirectory()) yield* typescriptFiles(file);
|
|
else if (file.endsWith('.ts')) yield file;
|
|
}
|
|
}
|
|
|
|
function extractImports(source) {
|
|
const imports = [];
|
|
const staticImport = /\bimport\s+(?!\()(?:(?:type\s+)?([^;\n]+?)\s+from\s+)?(['"])([^'"\n]+)\2/g;
|
|
for (const match of source.matchAll(staticImport)) {
|
|
imports.push({ specifier: match[3], bindings: match[1] ?? '' });
|
|
}
|
|
const dynamicImport = /\bimport\s*\(\s*(['"])([^'"\n]+)\1\s*\)/g;
|
|
for (const match of source.matchAll(dynamicImport)) {
|
|
imports.push({ specifier: match[2], bindings: '' });
|
|
}
|
|
return imports;
|
|
}
|
|
|
|
function findViolation(context) {
|
|
const { file, specifier, bindings, resolved, frameworkDir, gamesDir } = context;
|
|
const filePath = displayPath(file);
|
|
const resolvedPath = resolved ? displayPath(resolved) : specifier;
|
|
const isContract = CONTRACTS_PATH.test(filePath);
|
|
const isGame = isInside(file, gamesDir);
|
|
const isFramework = isInside(file, frameworkDir);
|
|
|
|
if (isContract && specifier === 'cc') {
|
|
return violation(filePath, specifier, `sdk/contracts cannot import cc (${filePath})`);
|
|
}
|
|
|
|
if (isContract && resolved && dirname(resolved) !== dirname(file)) {
|
|
return violation(filePath, specifier, `sdk/contracts may import only sibling contracts; sdk path resolved to ${resolvedPath}`);
|
|
}
|
|
|
|
if (isGame && resolved && isFrameworkReference(resolved, frameworkDir) && !SDK_ALLOWED.test(resolvedPath)) {
|
|
return violation(filePath, specifier, `game code may import only framework/sdk; game import resolved to ${resolvedPath}`);
|
|
}
|
|
|
|
if (isGame && resolved && SDK_ALLOWED.test(resolvedPath) && importsMigrationOnlyName(bindings)) {
|
|
return violation(filePath, specifier, `game code cannot import ${migrationOnlyName(bindings)}; it is migration-only`);
|
|
}
|
|
|
|
if (isFramework && resolved && isInside(resolved, gamesDir)) {
|
|
return violation(filePath, specifier, `framework code cannot import games; framework import resolved to ${resolvedPath}`);
|
|
}
|
|
|
|
if (resolved && LEGACY_RUNTIME.test(resolvedPath) && !isLegacyRuntimeImporter(filePath, frameworkDir)) {
|
|
return violation(filePath, specifier, `new production code cannot import quarantined legacy runtime ${resolvedPath}`);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function isFrameworkReference(path, frameworkDir) {
|
|
return isInside(path, frameworkDir)
|
|
|| SDK_ALLOWED.test(path)
|
|
|| FRAMEWORK_INTERNAL.test(path)
|
|
|| /(?:^|[\\/])framework(?:[\\/]|$)/.test(path);
|
|
}
|
|
|
|
function isLegacyRuntimeImporter(filePath, frameworkDir) {
|
|
const normalizedFrameworkDir = displayPath(frameworkDir);
|
|
return filePath === `${normalizedFrameworkDir}/sdk/index.ts` || LEGACY_RUNTIME.test(filePath);
|
|
}
|
|
|
|
function importsMigrationOnlyName(bindings) {
|
|
return [...MIGRATION_ONLY_NAMES].some((name) => new RegExp(`\\b${name}\\b`).test(bindings));
|
|
}
|
|
|
|
function migrationOnlyName(bindings) {
|
|
return [...MIGRATION_ONLY_NAMES].find((name) => new RegExp(`\\b${name}\\b`).test(bindings));
|
|
}
|
|
|
|
function isInside(file, directory) {
|
|
const pathFromDirectory = relative(directory, file);
|
|
return pathFromDirectory !== '' && !pathFromDirectory.startsWith('..') && !isAbsolute(pathFromDirectory);
|
|
}
|
|
|
|
function displayPath(file) {
|
|
return file.replaceAll('\\', '/');
|
|
}
|
|
|
|
function violation(file, specifier, message) {
|
|
return { file, specifier, message };
|
|
}
|
|
|
|
export { FRAMEWORK_INTERNAL, LEGACY_RUNTIME, SDK_ALLOWED };
|