proteum 2.4.4 → 2.5.1

package/cli/compiler/artifacts/controllers.ts

@@ -8,7 +8,7 @@ import writeIfChanged from '../writeIfChanged';
 import { resolveConnectedProjectContracts, writeConnectedProjectContract } from './connectedProjects';
 import { normalizeAbsolutePath } from './shared';
 
-const reservedConnectedContextKeys = new Set(['app', 'context', 'request', 'response', 'route', 'api', 'Router']);
+const reservedConnectedContextKeys = new Set(['app', 'services', 'context', 'request', 'response', 'route', 'api', 'Router']);
 
 const getManifestScopeFromImportPath = (importPath: string) =>
     importPath.startsWith('@server/controllers/') ? 'framework' : 'app';
@@ -70,10 +70,11 @@ export const generateControllerArtifacts = async () => {
     const typeImports: string[] = [];
 
     localControllers.forEach((controller, index) => {
-        typeImports.push(`import type Controller${index} from ${JSON.stringify(controller.importPath)};`);
+        typeImports.push(`type Controller${index} = typeof import(${JSON.stringify(controller.importPath)}).default;`);
 
         controller.methods.forEach((method) => {
-            const resultType = `TControllerResult<Controller${index}, ${JSON.stringify(method.name)}>`;
+            const resultType = `TControllerActionResult<Controller${index}, ${JSON.stringify(method.name)}>`;
+            const inputType = `TControllerActionInput<Controller${index}, ${JSON.stringify(method.name)}>`;
             const clientAccessor = method.routePath.split('/').join('.');
 
             manifestControllers.push({
@@ -98,6 +99,7 @@ export const generateControllerArtifacts = async () => {
                     connected: undefined,
                     hasInput: method.inputCallsCount > 0,
                     httpPath: '/api/' + method.routePath,
+                    inputType,
                     methodName: method.name,
                     resultType,
                     typeName: `Controller${index}`,
@@ -109,6 +111,7 @@ export const generateControllerArtifacts = async () => {
                 clientAccessor,
                 JSON.stringify({
                     hasInput: method.inputCallsCount > 0,
+                    inputType,
                     methodName: method.name,
                     typeName: `Controller${index}`,
                 }),
@@ -183,6 +186,7 @@ export const generateControllerArtifacts = async () => {
             };
             hasInput: boolean;
             httpPath: string;
+            inputType?: string;
             resultType: string;
         };
 
@@ -191,7 +195,7 @@ export const generateControllerArtifacts = async () => {
             : '';
 
         return meta.hasInput
-            ? `(data) => api.createFetcher<${meta.resultType}>('POST', ${JSON.stringify(meta.httpPath)}, data${connectedOptions})`
+            ? `(data: ${meta.inputType || 'any'}) => api.createFetcher<${meta.resultType}>('POST', ${JSON.stringify(meta.httpPath)}, data as TPostDataWithFile${connectedOptions})`
             : `() => api.createFetcher<${meta.resultType}>('POST', ${JSON.stringify(meta.httpPath)}, undefined${connectedOptions})`;
     };
 
@@ -205,15 +209,16 @@ export const generateControllerArtifacts = async () => {
               }
             | {
                   hasInput: boolean;
+                  inputType?: string;
                   methodName: string;
                   typeName: string;
               };
 
         if ('rawType' in meta) return meta.rawType;
         if ('runtimeOnly' in meta) return 'any';
-        const fetcherType = `TControllerFetcher<${meta.typeName}, ${JSON.stringify(meta.methodName)}>`;
+        const fetcherType = `TFetcher<TControllerActionResult<${meta.typeName}, ${JSON.stringify(meta.methodName)}>>`;
 
-        return meta.hasInput ? `(data: any) => ${fetcherType}` : `() => ${fetcherType}`;
+        return meta.hasInput ? `(data: ${meta.inputType || 'any'}) => ${fetcherType}` : `() => ${fetcherType}`;
     };
 
     const createControllersContent = `/*----------------------------------
@@ -224,14 +229,10 @@ export const generateControllerArtifacts = async () => {
 // Do not edit it manually.
 
 import type ApiClient from '@common/router/request/api';
-import type { TFetcher } from '@common/router/request/api';
+import type { TFetcher, TPostDataWithFile } from '@common/router/request/api';
+import type { TControllerActionInput, TControllerActionResult } from '@server/app/controller';
 ${[...typeImports, ...connectedControllerTypeImports].join('\n') ? '\n' + [...typeImports, ...connectedControllerTypeImports].join('\n') : ''}
 
-type TControllerResult<TController, TMethod extends keyof TController> =
-    TController[TMethod] extends (...args: any[]) => infer TResult ? Awaited<TResult> : never;
-
-type TControllerFetcher<TController, TMethod extends keyof TController> = TFetcher<TControllerResult<TController, TMethod>>;
-
 type TConnectedFallbackValue =
     | string
     | number
@@ -284,7 +285,7 @@ export type { TControllers } from '@generated/common/controllers';
         path: ${JSON.stringify('/api/' + method.routePath)},
         filepath: ${JSON.stringify(normalizeAbsolutePath(controller.filepath))},
         sourceLocation: { line: ${method.sourceLocation.line}, column: ${method.sourceLocation.column} },
-        Controller: Controller${controllerIndex},
+        action: Controller${controllerIndex}.actions[${JSON.stringify(method.name)}],
         method: ${JSON.stringify(method.name)},
     },`,
         ),
@@ -299,14 +300,14 @@ export type { TControllers } from '@generated/common/controllers';
 // This file is generated by Proteum from server controller files.
 // Do not edit it manually.
 
-import type Controller from '@server/app/controller';
+import type { TControllerActionDefinition } from '@server/app/controller';
 ${controllerImports ? '\n' + controllerImports : ''}
 
 export type TGeneratedControllerDefinition = {
     path: string,
     filepath: string,
     sourceLocation: { line: number, column: number },
-    Controller: new (request: any) => Controller,
+    action: TControllerActionDefinition<any, any, any, any>,
     method: string,
 }
 

package/cli/compiler/artifacts/discovery.ts

@@ -2,11 +2,32 @@ import path from 'path';
 import fs from 'fs-extra';
 import ts from 'typescript';
 
-import app from '../../app';
 import { normalizePath } from './shared';
 
-const hasRegisteredRouteDefinitions = (filepath: string, content: string) => {
-    const sourceFile = ts.createSourceFile(
+type TRouteSide = 'client' | 'server';
+
+const legacyRouterMethods = new Set([
+    'page',
+    'error',
+    'all',
+    'options',
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+    'express',
+]);
+const routeDefinitionHelpers = new Set([
+    'definePageRoute',
+    'defineErrorRoute',
+    'defineServerRoute',
+    'defineServerRoutes',
+]);
+const routeDefinitionImportSources = new Set(['@common/router', '@common/router/definitions']);
+
+const parseSourceFile = (filepath: string, content: string) =>
+    ts.createSourceFile(
         filepath,
         content,
         ts.ScriptTarget.Latest,
@@ -14,22 +35,110 @@ const hasRegisteredRouteDefinitions = (filepath: string, content: string) => {
         filepath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
     );
 
-    return sourceFile.statements.some((statement) => {
-        if (!ts.isExpressionStatement(statement)) return false;
-        if (!ts.isCallExpression(statement.expression)) return false;
-        if (!ts.isPropertyAccessExpression(statement.expression.expression)) return false;
+const getCallExpressionName = (node: ts.Expression) => {
+    if (ts.isIdentifier(node)) return node.text;
+    if (ts.isPropertyAccessExpression(node)) return node.name.text;
+    return undefined;
+};
 
-        const callee = statement.expression.expression;
+const collectConstInitializers = (sourceFile: ts.SourceFile) => {
+    const initializers = new Map<string, ts.Expression>();
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) continue;
+        if (!(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
+
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+
+            initializers.set(declaration.name.text, declaration.initializer);
+        }
+    }
+
+    return initializers;
+};
+
+const resolveIdentifierExpression = (
+    expression: ts.Expression,
+    constInitializers: Map<string, ts.Expression>,
+): ts.Expression => {
+    if (!ts.isIdentifier(expression)) return expression;
+
+    return constInitializers.get(expression.text) || expression;
+};
+
+const getDefaultExportExpression = (sourceFile: ts.SourceFile) => {
+    const constInitializers = collectConstInitializers(sourceFile);
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+
+        return resolveIdentifierExpression(statement.expression, constInitializers);
+    }
+
+    return undefined;
+};
 
-        return (
-            ts.isIdentifier(callee.expression) &&
-            callee.expression.text === 'Router' &&
-            ['page', 'error', 'get', 'post', 'put', 'delete', 'patch'].includes(callee.name.text)
+const hasRouteDefinitionHelperImport = (sourceFile: ts.SourceFile) =>
+    sourceFile.statements.some((statement) => {
+        if (!ts.isImportDeclaration(statement)) return false;
+        if (!ts.isStringLiteral(statement.moduleSpecifier)) return false;
+        if (!routeDefinitionImportSources.has(statement.moduleSpecifier.text)) return false;
+        if (!statement.importClause?.namedBindings) return false;
+        if (!ts.isNamedImports(statement.importClause.namedBindings)) return false;
+
+        return statement.importClause.namedBindings.elements.some((specifier) =>
+            routeDefinitionHelpers.has(specifier.propertyName?.text || specifier.name.text),
         );
     });
+
+const hasExplicitRouteDefinitionExport = (sourceFile: ts.SourceFile) => {
+    const defaultExportExpression = getDefaultExportExpression(sourceFile);
+
+    return (
+        !!defaultExportExpression &&
+        ts.isCallExpression(defaultExportExpression) &&
+        !!getCallExpressionName(defaultExportExpression.expression) &&
+        routeDefinitionHelpers.has(getCallExpressionName(defaultExportExpression.expression)!)
+    );
+};
+
+const hasLegacyRouteMagic = (sourceFile: ts.SourceFile, side: TRouteSide) => {
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+            if (statement.moduleSpecifier.text === '@app') return true;
+        }
+
+        if (!ts.isExpressionStatement(statement)) continue;
+        if (!ts.isCallExpression(statement.expression)) continue;
+        if (!ts.isPropertyAccessExpression(statement.expression.expression)) continue;
+
+        const callee = statement.expression.expression;
+        if (!ts.isIdentifier(callee.expression)) continue;
+        if (callee.expression.text !== 'Router') continue;
+        if (!legacyRouterMethods.has(callee.name.text)) continue;
+
+        return true;
+    }
+
+    return false;
 };
 
-const findRegisteredRouteFiles = (dir: string, options: { excludeLayoutDirectories?: boolean } = {}): string[] => {
+const hasRegisteredRouteDefinitions = (filepath: string, content: string, side: TRouteSide) => {
+    const sourceFile = parseSourceFile(filepath, content);
+
+    return (
+        hasExplicitRouteDefinitionExport(sourceFile) ||
+        hasRouteDefinitionHelperImport(sourceFile) ||
+        hasLegacyRouteMagic(sourceFile, side)
+    );
+};
+
+const findRegisteredRouteFiles = (
+    dir: string,
+    side: TRouteSide,
+    options: { excludeLayoutDirectories?: boolean } = {},
+): string[] => {
     if (!fs.existsSync(dir)) return [];
 
     const files: string[] = [];
@@ -40,7 +149,7 @@ const findRegisteredRouteFiles = (dir: string, options: { excludeLayoutDirectori
         if (dirent.isDirectory()) {
             if (options.excludeLayoutDirectories && dirent.name === '_layout') continue;
 
-            files.push(...findRegisteredRouteFiles(filePath, options));
+            files.push(...findRegisteredRouteFiles(filePath, side, options));
             continue;
         }
 
@@ -48,7 +157,7 @@ const findRegisteredRouteFiles = (dir: string, options: { excludeLayoutDirectori
         if (!/\.(ts|tsx)$/.test(dirent.name)) continue;
 
         const content = fs.readFileSync(filePath, 'utf8');
-        if (!hasRegisteredRouteDefinitions(filePath, content)) continue;
+        if (!hasRegisteredRouteDefinitions(filePath, content, side)) continue;
 
         files.push(filePath);
     }
@@ -56,9 +165,11 @@ const findRegisteredRouteFiles = (dir: string, options: { excludeLayoutDirectori
     return files;
 };
 
-export const findClientRouteFiles = (dir: string) => findRegisteredRouteFiles(dir, { excludeLayoutDirectories: true });
+export const findClientRouteFiles = (dir: string) => findRegisteredRouteFiles(dir, 'client', { excludeLayoutDirectories: true });
+
+export const findServerRouteFiles = (dir: string) => findRegisteredRouteFiles(dir, 'server');
 
-export const findServerRouteFiles = (dir: string) => findRegisteredRouteFiles(dir);
+const getApp = () => require('../../app').default as typeof import('../../app').default;
 
 export const findLayoutFiles = (dir: string): string[] => {
     if (!fs.existsSync(dir)) return [];
@@ -84,6 +195,7 @@ export const findLayoutFiles = (dir: string): string[] => {
 };
 
 export const readPreloadedRouteChunks = () => {
+    const app = getApp();
     const preloadPath = path.join(app.paths.pages, 'preload.json');
 
     if (!fs.existsSync(preloadPath)) return new Set<string>();

package/cli/compiler/artifacts/routing.ts

@@ -89,7 +89,6 @@ const buildServerRouteManifestEntries = (filepath: string) =>
 
 const generateClientRouteWrapperModules = () => {
     const clientRouteFiles = findClientRouteFiles(app.paths.pages).sort((a, b) => a.localeCompare(b));
-    const routeSourceFilepaths = new Set(clientRouteFiles.map((filepath) => normalizePath(path.resolve(filepath))));
     const routes = clientRouteFiles.map((filepath) => buildClientRouteManifestEntry(filepath));
 
     for (const filepath of clientRouteFiles) {
@@ -101,7 +100,6 @@ const generateClientRouteWrapperModules = () => {
             side: 'client',
             sourceFilepath: filepath,
             clientRoute: { chunkId: pageChunk.chunkId },
-            routeSourceFilepaths,
         });
 
         writeGeneratedRouteModule({
@@ -110,7 +108,6 @@ const generateClientRouteWrapperModules = () => {
             side: 'client',
             sourceFilepath: filepath,
             clientRoute: { chunkId: pageChunk.chunkId },
-            routeSourceFilepaths,
         });
     }
 
@@ -121,7 +118,6 @@ const generateServerRouteWrapperModules = () => {
     const serverRouteFiles = findServerRouteFiles(path.join(app.paths.root, 'server', 'routes')).sort((a, b) =>
         a.localeCompare(b),
     );
-    const routeSourceFilepaths = new Set(serverRouteFiles.map((filepath) => normalizePath(path.resolve(filepath))));
     const routes = serverRouteFiles.flatMap((filepath) => buildServerRouteManifestEntries(filepath));
 
     for (const filepath of serverRouteFiles) {
@@ -130,7 +126,6 @@ const generateServerRouteWrapperModules = () => {
             runtime: 'server',
             side: 'server',
             sourceFilepath: filepath,
-            routeSourceFilepaths,
         });
     }