proteum 2.4.4 → 2.5.1

package/scripts/migrate-explicit-controllers-and-request.ts

@@ -1,423 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { parse } from '@babel/parser';
-import traverse from '@babel/traverse';
-import generate from '@babel/generator';
-import * as t from '@babel/types';
-
-type TControllerRouteMap = Map<string, string>;
-
-const parserPlugins = [
-    'typescript',
-    'jsx',
-    'classProperties',
-    'classPrivateProperties',
-    'classPrivateMethods',
-    'decorators-legacy',
-    'objectRestSpread',
-    'optionalChaining',
-    'nullishCoalescingOperator',
-] as const;
-
-const parseModule = (filepath: string, code: string) =>
-    parse(code, {
-        sourceType: 'module',
-        sourceFilename: filepath,
-        plugins: [...parserPlugins],
-    });
-
-const generateModule = (ast: ReturnType<typeof parse>) =>
-    generate(ast, {
-        retainLines: false,
-        decoratorsBeforeExport: true,
-        jsescOption: { minimal: true },
-    }).code + '\n';
-
-const ensureRelativeImport = (value: string) =>
-    value.startsWith('.') ? value : value.startsWith('/') ? value : './' + value;
-
-const stripTsExtension = (filepath: string) => filepath.replace(/\.(tsx?|jsx?)$/, '');
-
-const resolveImportFile = (fromDir: string, source: string) => {
-    const candidates = [
-        path.resolve(fromDir, source),
-        path.resolve(fromDir, source + '.ts'),
-        path.resolve(fromDir, source + '.tsx'),
-        path.resolve(fromDir, source + '.js'),
-        path.resolve(fromDir, source + '.jsx'),
-        path.resolve(fromDir, source, 'index.ts'),
-        path.resolve(fromDir, source, 'index.tsx'),
-        path.resolve(fromDir, source, 'index.js'),
-        path.resolve(fromDir, source, 'index.jsx'),
-    ];
-
-    return candidates.find((candidate) => fs.existsSync(candidate));
-};
-
-const parseControllerRoutes = (repoRoot: string): TControllerRouteMap => {
-    const generatedPath = path.join(repoRoot, '.proteum', 'server', 'controllers.ts');
-    const code = fs.readFileSync(generatedPath, 'utf8');
-    const importRegex = /import\s+(Controller\d+)\s+from\s+"(@\/server\/services\/[^"]+)";/g;
-    const routeRegex =
-        /\{\s*path:\s*"([^"]+)",\s*Controller:\s*(Controller\d+),\s*method:\s*"([^"]+)"\s*,?\s*\}/g;
-
-    const controllerImportById = new Map<string, string>();
-    const routeBaseByImportPath = new Map<string, string>();
-
-    for (const match of code.matchAll(importRegex)) {
-        controllerImportById.set(match[1], match[2]);
-    }
-
-    for (const match of code.matchAll(routeRegex)) {
-        const httpPath = match[1];
-        const controllerId = match[2];
-        const importPath = controllerImportById.get(controllerId);
-
-        if (!importPath) continue;
-
-        const segments = httpPath.replace(/^\/api\//, '').split('/').filter(Boolean);
-        const routeBasePath = segments.slice(0, -1).join('/');
-
-        if (!routeBasePath) continue;
-        if (!routeBaseByImportPath.has(importPath)) routeBaseByImportPath.set(importPath, routeBasePath);
-    }
-
-    return routeBaseByImportPath;
-};
-
-const rewriteRelativeImports = (code: string, fromFilepath: string, toFilepath: string) => {
-    const ast = parseModule(fromFilepath, code);
-
-    traverse(ast, {
-        ImportDeclaration(importPath) {
-            const source = importPath.node.source.value;
-            if (typeof source !== 'string' || !source.startsWith('.')) return;
-
-            const resolved = resolveImportFile(path.dirname(fromFilepath), source);
-            if (!resolved) return;
-
-            const relative = stripTsExtension(path.relative(path.dirname(toFilepath), resolved)).replace(/\\/g, '/');
-            importPath.node.source = t.stringLiteral(ensureRelativeImport(relative));
-        },
-    });
-
-    return generateModule(ast);
-};
-
-const isThisMember = (node: t.Node | null | undefined, propertyName: string): node is t.MemberExpression =>
-    !!node &&
-    t.isMemberExpression(node) &&
-    t.isThisExpression(node.object) &&
-    !node.computed &&
-    t.isIdentifier(node.property, { name: propertyName });
-
-const getMemberRoot = (node: t.Expression | t.PrivateName): t.Expression | t.PrivateName => {
-    let current: t.Expression | t.PrivateName = node;
-
-    while (t.isMemberExpression(current) || t.isOptionalMemberExpression(current)) {
-        current = current.object;
-    }
-
-    return current;
-};
-
-const collectPatternNames = (pattern: t.LVal, names: Set<string>) => {
-    if (t.isIdentifier(pattern)) {
-        names.add(pattern.name);
-        return;
-    }
-
-    if (t.isObjectPattern(pattern)) {
-        for (const property of pattern.properties) {
-            if (t.isRestElement(property)) {
-                collectPatternNames(property.argument, names);
-                continue;
-            }
-
-            if (t.isObjectProperty(property)) {
-                collectPatternNames(property.value as t.LVal, names);
-            }
-        }
-        return;
-    }
-
-    if (t.isArrayPattern(pattern)) {
-        for (const element of pattern.elements) {
-            if (!element) continue;
-            if (t.isRestElement(element)) {
-                collectPatternNames(element.argument, names);
-                continue;
-            }
-            collectPatternNames(element, names);
-        }
-    }
-};
-
-const isServiceLikeBinding = (init: t.Expression | null | undefined) => {
-    if (!init) return false;
-    if (isThisMember(init, 'services')) return true;
-    if (isThisMember(init, 'app')) return true;
-
-    if (t.isMemberExpression(init) || t.isOptionalMemberExpression(init)) {
-        const root = getMemberRoot(init);
-        return isThisMember(root, 'services') || isThisMember(root, 'app') || isThisMember(root, 'parent');
-    }
-
-    return false;
-};
-
-const hasExplicitRequestArgument = (args: Array<t.Expression | t.SpreadElement | t.ArgumentPlaceholder>) =>
-    args.some(
-        (arg) =>
-            t.isIdentifier(arg, { name: 'request' }) ||
-            (t.isMemberExpression(arg) &&
-                isThisMember(arg.object, 'request') &&
-                !arg.computed &&
-                t.isIdentifier(arg.property)),
-    );
-
-const appendRequestArgument = (
-    callPath: { node: t.CallExpression | t.OptionalCallExpression },
-    requestExpression: t.Expression,
-) => {
-    if (hasExplicitRequestArgument(callPath.node.arguments)) return;
-    callPath.node.arguments.push(requestExpression);
-};
-
-const transformControllerFile = (filepath: string) => {
-    const code = fs.readFileSync(filepath, 'utf8');
-    const ast = parseModule(filepath, code);
-    const serviceBindings = new Set<string>();
-    let changed = false;
-
-    traverse(ast, {
-        VariableDeclarator(variablePath) {
-            if (!isServiceLikeBinding(variablePath.node.init as t.Expression | null | undefined)) return;
-            collectPatternNames(variablePath.node.id, serviceBindings);
-        },
-        CallExpression(callPath) {
-            const callee = callPath.node.callee;
-            if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) return;
-
-            const root = getMemberRoot(callee);
-            const isDirectServiceCall =
-                isThisMember(root, 'services') || isThisMember(root, 'app') || isThisMember(root, 'parent');
-            const isBoundServiceCall = t.isIdentifier(root) && serviceBindings.has(root.name);
-
-            if (!isDirectServiceCall && !isBoundServiceCall) return;
-
-            appendRequestArgument(callPath as { node: t.CallExpression }, t.memberExpression(t.thisExpression(), t.identifier('request')));
-            changed = true;
-        },
-        OptionalCallExpression(callPath) {
-            const callee = callPath.node.callee;
-            if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) return;
-
-            const root = getMemberRoot(callee);
-            const isDirectServiceCall =
-                isThisMember(root, 'services') || isThisMember(root, 'app') || isThisMember(root, 'parent');
-            const isBoundServiceCall = t.isIdentifier(root) && serviceBindings.has(root.name);
-
-            if (!isDirectServiceCall && !isBoundServiceCall) return;
-
-            appendRequestArgument(
-                callPath as { node: t.OptionalCallExpression },
-                t.memberExpression(t.thisExpression(), t.identifier('request')),
-            );
-            changed = true;
-        },
-    });
-
-    if (!changed) return;
-    fs.writeFileSync(filepath, generateModule(ast));
-};
-
-const ensureTypeImport = (ast: ReturnType<typeof parse>) => {
-    let hasTypeImport = false;
-    let serviceImport: t.ImportDeclaration | null = null;
-
-    for (const statement of ast.program.body) {
-        if (!t.isImportDeclaration(statement)) continue;
-        if (statement.source.value !== '@server/app/service') continue;
-
-        serviceImport = statement;
-        for (const specifier of statement.specifiers) {
-            if (
-                t.isImportSpecifier(specifier) &&
-                t.isIdentifier(specifier.imported, { name: 'TServiceRequestContext' })
-            ) {
-                hasTypeImport = true;
-            }
-        }
-    }
-
-    if (hasTypeImport) return;
-
-    if (serviceImport) {
-        serviceImport.specifiers.push(
-            t.importSpecifier(t.identifier('TServiceRequestContext'), t.identifier('TServiceRequestContext')),
-        );
-        return;
-    }
-
-    const importDeclaration = t.importDeclaration(
-        [t.importSpecifier(t.identifier('TServiceRequestContext'), t.identifier('TServiceRequestContext'))],
-        t.stringLiteral('@server/app/service'),
-    );
-    importDeclaration.importKind = 'type';
-    ast.program.body.unshift(importDeclaration);
-};
-
-const usesAmbientRequest = (methodPath: any) => {
-    let found = false;
-
-    methodPath.traverse({
-        MemberExpression(memberPath: any) {
-            if (isThisMember(memberPath.node, 'request')) {
-                found = true;
-                memberPath.stop();
-            }
-        },
-        OptionalMemberExpression(memberPath: any) {
-            if (isThisMember(memberPath.node, 'request')) {
-                found = true;
-                memberPath.stop();
-            }
-        },
-    });
-
-    return found;
-};
-
-const transformServiceFile = (filepath: string) => {
-    const code = fs.readFileSync(filepath, 'utf8');
-    const ast = parseModule(filepath, code);
-    let changed = false;
-
-    traverse(ast, {
-        ClassMethod(methodPath) {
-            if (!methodPath.node.body) return;
-            if (!usesAmbientRequest(methodPath)) return;
-
-            const hasRequestParam = methodPath.node.params.some(
-                (param) => t.isIdentifier(param) && param.name === 'request',
-            );
-            if (!hasRequestParam) {
-                const requestParam = t.identifier('request');
-                requestParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('TServiceRequestContext')));
-                methodPath.node.params.push(requestParam);
-            }
-
-            methodPath.traverse({
-                MemberExpression(memberPath) {
-                    if (!isThisMember(memberPath.node, 'request')) return;
-                    memberPath.replaceWith(t.identifier('request'));
-                },
-                OptionalMemberExpression(memberPath) {
-                    if (!isThisMember(memberPath.node, 'request')) return;
-                    memberPath.replaceWith(t.identifier('request'));
-                },
-                CallExpression(callPath) {
-                    const callee = callPath.node.callee;
-                    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) return;
-
-                    const root = getMemberRoot(callee);
-                    if (!isThisMember(root, 'app') && !isThisMember(root, 'services') && !isThisMember(root, 'parent')) {
-                        return;
-                    }
-
-                    appendRequestArgument(callPath as { node: t.CallExpression }, t.identifier('request'));
-                },
-                OptionalCallExpression(callPath) {
-                    const callee = callPath.node.callee;
-                    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) return;
-
-                    const root = getMemberRoot(callee);
-                    if (!isThisMember(root, 'app') && !isThisMember(root, 'services') && !isThisMember(root, 'parent')) {
-                        return;
-                    }
-
-                    appendRequestArgument(callPath as { node: t.OptionalCallExpression }, t.identifier('request'));
-                },
-            });
-
-            changed = true;
-        },
-    });
-
-    if (!changed) return;
-
-    ensureTypeImport(ast);
-    fs.writeFileSync(filepath, generateModule(ast));
-};
-
-const findFiles = (dir: string, predicate: (filepath: string) => boolean, results: string[] = []) => {
-    if (!fs.existsSync(dir)) return results;
-
-    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
-        const filepath = path.join(dir, dirent.name);
-
-        if (dirent.isDirectory()) {
-            findFiles(filepath, predicate, results);
-            continue;
-        }
-
-        if (dirent.isFile() && predicate(filepath)) {
-            results.push(filepath);
-        }
-    }
-
-    return results;
-};
-
-const moveControllers = (repoRoot: string) => {
-    const routeMap = parseControllerRoutes(repoRoot);
-
-    for (const [importPath, routeBasePath] of routeMap) {
-        const sourceFile = path.join(repoRoot, importPath.replace('@/', '') + '.ts');
-        const targetFile = path.join(repoRoot, 'server', 'controllers', ...routeBasePath.split('/')) + '.ts';
-
-        if (!fs.existsSync(sourceFile)) continue;
-
-        const content = fs.readFileSync(sourceFile, 'utf8');
-        const rewritten = rewriteRelativeImports(content, sourceFile, targetFile);
-
-        fs.ensureDirSync(path.dirname(targetFile));
-        fs.writeFileSync(targetFile, rewritten);
-        fs.removeSync(sourceFile);
-        transformControllerFile(targetFile);
-    }
-};
-
-const migrateServiceRequestUsage = (repoRoot: string) => {
-    const serviceFiles = findFiles(
-        path.join(repoRoot, 'server', 'services'),
-        (filepath) =>
-            /\.(ts|tsx)$/.test(filepath) &&
-            !filepath.endsWith('.controller.ts') &&
-            !filepath.includes(`${path.sep}router${path.sep}request.ts`),
-    );
-
-    for (const filepath of serviceFiles) {
-        const content = fs.readFileSync(filepath, 'utf8');
-        if (!content.includes('this.request')) continue;
-        if (content.includes('extends RequestService')) continue;
-
-        transformServiceFile(filepath);
-    }
-};
-
-const migrateRepo = (repoRoot: string) => {
-    moveControllers(repoRoot);
-    migrateServiceRequestUsage(repoRoot);
-};
-
-const repoRoots = process.argv.slice(2);
-
-if (!repoRoots.length) {
-    throw new Error('Usage: ts-node scripts/migrate-explicit-controllers-and-request.ts <repo-root> [repo-root...]');
-}
-
-for (const repoRoot of repoRoots) {
-    migrateRepo(path.resolve(repoRoot));
-}

package/scripts/refactor-client-app-imports.ts

@@ -1,244 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { parse } from '@babel/parser';
-import traverse, { NodePath } from '@babel/traverse';
-import generate from '@babel/generator';
-import * as types from '@babel/types';
-
-const findFiles = (dir: string): string[] => {
-    if (!fs.existsSync(dir)) return [];
-
-    const files: string[] = [];
-
-    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
-        const filepath = path.join(dir, dirent.name);
-
-        if (dirent.isDirectory()) {
-            files.push(...findFiles(filepath));
-            continue;
-        }
-
-        if (dirent.isFile() && /\.(tsx?|jsx?)$/.test(filepath)) files.push(filepath);
-    }
-
-    return files;
-};
-
-const isFunctionLikePath = (path: NodePath) =>
-    path.isFunctionDeclaration() ||
-    path.isFunctionExpression() ||
-    path.isArrowFunctionExpression() ||
-    path.isObjectMethod() ||
-    path.isClassMethod();
-
-const getOutermostFunctionPath = (path: NodePath) => {
-    let current: NodePath | null = path;
-    let lastFunctionPath: NodePath | null = null;
-
-    while (current && !current.isProgram()) {
-        if (isFunctionLikePath(current)) lastFunctionPath = current;
-
-        current = current.parentPath;
-    }
-
-    return lastFunctionPath;
-};
-
-const ensureUseContextImport = (programPath: NodePath<types.Program>) => {
-    for (const statement of programPath.node.body) {
-        if (
-            statement.type === 'ImportDeclaration' &&
-            statement.source.value === '@/client/context' &&
-            statement.specifiers.some(
-                (specifier) => specifier.type === 'ImportDefaultSpecifier' && specifier.local.name === 'useContext',
-            )
-        )
-            return;
-    }
-
-    programPath.unshiftContainer(
-        'body',
-        types.importDeclaration(
-            [types.importDefaultSpecifier(types.identifier('useContext'))],
-            types.stringLiteral('@/client/context'),
-        ),
-    );
-};
-
-const ensureBlockBody = (functionPath: NodePath) => {
-    if (functionPath.isArrowFunctionExpression() && functionPath.node.body.type !== 'BlockStatement') {
-        functionPath.node.body = types.blockStatement([types.returnStatement(functionPath.node.body)]);
-    }
-
-    return functionPath.get('body') as NodePath<types.BlockStatement>;
-};
-
-const hasExistingUseContextDeclaration = (bodyPath: NodePath<types.BlockStatement>, names: string[]) => {
-    return bodyPath.node.body.some(
-        (statement) =>
-            statement.type === 'VariableDeclaration' &&
-            statement.declarations.some(
-                (declaration) =>
-                    declaration.id.type === 'ObjectPattern' &&
-                    declaration.init?.type === 'CallExpression' &&
-                    declaration.init.callee.type === 'Identifier' &&
-                    declaration.init.callee.name === 'useContext' &&
-                    names.every((name) =>
-                        declaration.id.properties.some(
-                            (property) =>
-                                property.type === 'ObjectProperty' &&
-                                property.key.type === 'Identifier' &&
-                                property.key.name === name,
-                        ),
-                    ),
-            ),
-    );
-};
-
-const objectPatternHasProperty = (pattern: types.ObjectPattern, localName: string) =>
-    pattern.properties.some(
-        (property) =>
-            property.type === 'ObjectProperty' &&
-            property.value.type === 'Identifier' &&
-            property.value.name === localName,
-    );
-
-const addObjectPatternProperty = (pattern: types.ObjectPattern, keyName: string, localName: string = keyName) => {
-    if (objectPatternHasProperty(pattern, localName)) return;
-
-    pattern.properties.push(
-        types.objectProperty(types.identifier(keyName), types.identifier(localName), false, keyName === localName),
-    );
-};
-
-const getUseContextStatements = (bodyPath: NodePath<types.BlockStatement>) => {
-    return bodyPath
-        .get('body')
-        .filter(
-            (statementPath) =>
-                statementPath.isVariableDeclaration() &&
-                statementPath.node.declarations.length === 1 &&
-                statementPath.node.declarations[0].id.type === 'ObjectPattern' &&
-                statementPath.node.declarations[0].init?.type === 'CallExpression' &&
-                statementPath.node.declarations[0].init.callee.type === 'Identifier' &&
-                statementPath.node.declarations[0].init.callee.name === 'useContext',
-        ) as NodePath<types.VariableDeclaration>[];
-};
-
-const repoRoots = process.argv.slice(2);
-if (!repoRoots.length)
-    throw new Error('Usage: ts-node scripts/refactor-client-app-imports.ts <repo-root> [repo-root...]');
-
-for (const repoRoot of repoRoots) {
-    const clientRoot = path.join(repoRoot, 'client');
-    const files = findFiles(clientRoot).filter((filepath) => !filepath.includes('/client/pages/'));
-    let changedFiles = 0;
-
-    for (const filepath of files) {
-        const code = fs.readFileSync(filepath, 'utf8');
-        if (!code.includes('@app') && !code.includes('"@app"')) continue;
-
-        const ast = parse(code, {
-            sourceType: 'module',
-            plugins: ['typescript', 'jsx', 'decorators-legacy', 'classProperties'],
-        });
-
-        const importedNames = new Set<string>();
-        const functionBindings = new Map<NodePath, Set<string>>();
-        let hasAppImport = false;
-
-        traverse(ast, {
-            ImportDeclaration(path) {
-                if (path.node.source.value !== '@app') return;
-
-                hasAppImport = true;
-
-                for (const specifier of path.node.specifiers) {
-                    if (specifier.type === 'ImportSpecifier' && specifier.imported.type === 'Identifier')
-                        importedNames.add(specifier.local.name);
-                }
-            },
-            Identifier(path) {
-                if (!importedNames.has(path.node.name)) return;
-
-                if (!path.isReferencedIdentifier()) return;
-
-                const binding = path.scope.getBinding(path.node.name);
-                if (!binding?.path.isImportSpecifier()) return;
-
-                const functionPath = getOutermostFunctionPath(path);
-                if (!functionPath) return;
-
-                const names = functionBindings.get(functionPath) || new Set<string>();
-                names.add(path.node.name);
-                functionBindings.set(functionPath, names);
-            },
-        });
-
-        if (!hasAppImport) continue;
-
-        traverse(ast, {
-            Program(programPath) {
-                for (const statementPath of programPath.get('body')) {
-                    if (!statementPath.isImportDeclaration()) continue;
-
-                    if (statementPath.node.source.value === '@app') statementPath.remove();
-                }
-
-                ensureUseContextImport(programPath);
-            },
-        });
-
-        for (const [functionPath, namesSet] of functionBindings) {
-            const names = [...namesSet].sort((a, b) => a.localeCompare(b));
-            const bodyPath = ensureBlockBody(functionPath);
-            const useContextStatements = getUseContextStatements(bodyPath);
-
-            if (hasExistingUseContextDeclaration(bodyPath, names)) continue;
-
-            if (useContextStatements.length) {
-                const primaryDeclaration = useContextStatements[0].node.declarations[0];
-                const primaryPattern = primaryDeclaration.id as types.ObjectPattern;
-
-                for (const statementPath of useContextStatements.slice(1)) {
-                    const declaration = statementPath.node.declarations[0];
-                    const pattern = declaration.id as types.ObjectPattern;
-
-                    for (const property of pattern.properties) {
-                        if (
-                            property.type === 'ObjectProperty' &&
-                            property.key.type === 'Identifier' &&
-                            property.value.type === 'Identifier'
-                        )
-                            addObjectPatternProperty(primaryPattern, property.key.name, property.value.name);
-                    }
-
-                    statementPath.remove();
-                }
-
-                for (const name of names) addObjectPatternProperty(primaryPattern, name);
-
-                continue;
-            }
-
-            bodyPath.unshiftContainer(
-                'body',
-                types.variableDeclaration('const', [
-                    types.variableDeclarator(
-                        types.objectPattern(
-                            names.map((name) =>
-                                types.objectProperty(types.identifier(name), types.identifier(name), false, true),
-                            ),
-                        ),
-                        types.callExpression(types.identifier('useContext'), []),
-                    ),
-                ]),
-            );
-        }
-
-        fs.writeFileSync(filepath, generate(ast, {}, code).code);
-        changedFiles++;
-    }
-
-    console.log(`[refactor-client-app-imports] ${repoRoot}: changed ${changedFiles} files`);
-}