proteum 2.1.2 → 2.1.6

package/cli/compiler/artifacts/controllers.ts

@@ -2,70 +2,212 @@ import path from 'path';
 
 import app from '../../app';
 import cli from '../..';
-import { generateControllerClientTree, indexControllers, printControllerTree } from '../common/controllers';
+import { indexControllers, printControllerTree, type TControllerFileMeta } from '../common/controllers';
 import { TProteumManifestController } from '../common/proteumManifest';
 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 getManifestScopeFromImportPath = (importPath: string) =>
     importPath.startsWith('@server/controllers/') ? 'framework' : 'app';
 
-export const generateControllerArtifacts = () => {
-    const controllers = indexControllers([
+const insertTreeLeaf = (tree: Record<string, any>, accessor: string, value: string) => {
+    const segments = accessor.split('.').filter(Boolean);
+    let cursor = tree;
+
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        const isLeaf = index === segments.length - 1;
+
+        if (isLeaf) {
+            cursor[segment] = value;
+            return;
+        }
+
+        cursor[segment] = cursor[segment] || {};
+        cursor = cursor[segment];
+    }
+};
+
+const buildLocalControllers = (): TControllerFileMeta[] =>
+    indexControllers([
         { importPrefix: '@server/controllers/', root: path.join(cli.paths.core.root, 'server', 'controllers') },
         { importPrefix: '@/server/controllers/', root: path.join(app.paths.root, 'server', 'controllers') },
     ]);
-    const manifestControllers = controllers.flatMap<TProteumManifestController>((controller) =>
-        controller.methods.map((method) => ({
-            className: controller.className,
-            importPath: controller.importPath,
-            filepath: normalizeAbsolutePath(controller.filepath),
-            sourceLocation: method.sourceLocation,
-            routeBasePath: controller.routeBasePath,
-            methodName: method.name,
-            inputCallsCount: method.inputCallsCount,
-            hasInput: method.inputCallsCount > 0,
-            routePath: method.routePath,
-            httpPath: '/api/' + method.routePath,
-            clientAccessor: method.routePath.split('/').join('.'),
-            scope: getManifestScopeFromImportPath(controller.importPath),
-        })),
-    );
-    const clientTree = generateControllerClientTree(controllers);
 
-    const getControllerLeafMeta = (leaf: string) => {
-        const meta = JSON.parse(leaf) as {
-            routePath: string;
-            importPath: string;
-            className: string;
-            methodName: string;
-            hasInput: boolean;
-        };
-        const controllerIndex = controllers.findIndex((controller) => controller.importPath === meta.importPath);
+const assertConnectedProjectNamespaces = (localControllers: TControllerFileMeta[]) => {
+    const localTopLevelKeys = new Set<string>();
 
-        if (controllerIndex === -1) {
-            throw new Error(`Unable to find controller import ${meta.importPath} while generating controller types.`);
+    for (const controller of localControllers) {
+        for (const method of controller.methods) {
+            const topLevelKey = method.routePath.split('/')[0];
+            if (topLevelKey) localTopLevelKeys.add(topLevelKey);
         }
+    }
 
-        return { ...meta, controllerIndex };
-    };
+    for (const namespace of Object.keys(app.connectedProjects)) {
+        if (reservedConnectedContextKeys.has(namespace)) {
+            throw new Error(`Connected project namespace "${namespace}" collides with a reserved route context key.`);
+        }
+
+        if (localTopLevelKeys.has(namespace)) {
+            throw new Error(`Connected project namespace "${namespace}" collides with an existing local controller root.`);
+        }
+    }
+};
+
+export const generateControllerArtifacts = async () => {
+    const localControllers = buildLocalControllers();
+    assertConnectedProjectNamespaces(localControllers);
+    writeConnectedProjectContract(localControllers);
+
+    const connectedProjectContracts = await resolveConnectedProjectContracts(app.connectedProjects);
+    const manifestControllers: TProteumManifestController[] = [];
+    const runtimeTree: Record<string, any> = {};
+    const typeTree: Record<string, any> = {};
+    const typeImports: string[] = [];
+
+    localControllers.forEach((controller, index) => {
+        typeImports.push(`import type Controller${index} from ${JSON.stringify(controller.importPath)};`);
+
+        controller.methods.forEach((method) => {
+            const resultType = `TControllerResult<Controller${index}, ${JSON.stringify(method.name)}>`;
+            const clientAccessor = method.routePath.split('/').join('.');
+
+            manifestControllers.push({
+                className: controller.className,
+                importPath: controller.importPath,
+                filepath: normalizeAbsolutePath(controller.filepath),
+                sourceLocation: method.sourceLocation,
+                routeBasePath: controller.routeBasePath,
+                methodName: method.name,
+                inputCallsCount: method.inputCallsCount,
+                hasInput: method.inputCallsCount > 0,
+                routePath: method.routePath,
+                httpPath: '/api/' + method.routePath,
+                clientAccessor,
+                scope: getManifestScopeFromImportPath(controller.importPath),
+            });
+
+            insertTreeLeaf(
+                runtimeTree,
+                clientAccessor,
+                JSON.stringify({
+                    connected: undefined,
+                    hasInput: method.inputCallsCount > 0,
+                    httpPath: '/api/' + method.routePath,
+                    methodName: method.name,
+                    resultType,
+                    typeName: `Controller${index}`,
+                }),
+            );
+
+            insertTreeLeaf(
+                typeTree,
+                clientAccessor,
+                JSON.stringify({
+                    hasInput: method.inputCallsCount > 0,
+                    methodName: method.name,
+                    typeName: `Controller${index}`,
+                }),
+            );
+        });
+    });
+
+    const connectedControllerTypeImports: string[] = [];
+    const connectedManifestControllers: TProteumManifestController[] = [];
+
+    connectedProjectContracts.forEach(({ namespace, cachedContractFilepath, contract, sourceKind, sourceValue, typeImportModuleSpecifier, typingMode }) => {
+        if (typingMode === 'local-typed' && typeImportModuleSpecifier) {
+            const typeName = `ConnectedControllers_${namespace.replace(/[^A-Za-z0-9_$]+/g, '_')}`;
+            connectedControllerTypeImports.push(
+                `import type { TConnectedControllers as ${typeName} } from ${JSON.stringify(typeImportModuleSpecifier)};`,
+            );
+            typeTree[namespace] = JSON.stringify({ rawType: typeName });
+        } else {
+            typeTree[namespace] = JSON.stringify({ runtimeOnly: true });
+        }
+
+        contract.controllers.forEach((controller) => {
+            const clientAccessor = `${namespace}.${controller.clientAccessor}`;
+            connectedManifestControllers.push({
+                className: controller.className,
+                importPath: `connected:${namespace}/${controller.importPath}`,
+                filepath:
+                    sourceKind === 'file'
+                        ? normalizeAbsolutePath(path.join(sourceValue, controller.relativeFilepath))
+                        : cachedContractFilepath,
+                sourceLocation: controller.sourceLocation,
+                routeBasePath: controller.routeBasePath,
+                methodName: controller.methodName,
+                inputCallsCount: controller.inputCallsCount,
+                hasInput: controller.hasInput,
+                routePath: controller.routePath,
+                httpPath: controller.httpPath,
+                clientAccessor,
+                scope: 'connected',
+                connectedProjectNamespace: namespace,
+                connectedProjectIdentifier: contract.identity.identifier,
+            });
+
+            insertTreeLeaf(
+                runtimeTree,
+                clientAccessor,
+                JSON.stringify({
+                    connected: {
+                        controllerAccessor: controller.clientAccessor,
+                        httpPath: controller.httpPath,
+                        namespace,
+                    },
+                    hasInput: controller.hasInput,
+                    httpPath: controller.httpPath,
+                    methodName: controller.methodName,
+                    resultType: 'unknown',
+                }),
+            );
+        });
+    });
 
     const runtimeLeaf = (leaf: string) => {
-        const meta = getControllerLeafMeta(leaf);
-        const resultType = `TControllerResult<Controller${meta.controllerIndex}, ${JSON.stringify(meta.methodName)}>`;
+        const meta = JSON.parse(leaf) as {
+            connected?: {
+                controllerAccessor: string;
+                httpPath: string;
+                namespace: string;
+            };
+            hasInput: boolean;
+            httpPath: string;
+            resultType: string;
+        };
+
+        const connectedOptions = meta.connected
+            ? `, { connected: ${JSON.stringify(meta.connected)} }`
+            : '';
 
         return meta.hasInput
-            ? `(data) => api.createFetcher<${resultType}>('POST', ${JSON.stringify(meta.routePath)}, data)`
-            : `() => api.createFetcher<${resultType}>('POST', ${JSON.stringify(meta.routePath)})`;
+            ? `(data) => api.createFetcher<${meta.resultType}>('POST', ${JSON.stringify(meta.httpPath)}, data${connectedOptions})`
+            : `() => api.createFetcher<${meta.resultType}>('POST', ${JSON.stringify(meta.httpPath)}, undefined${connectedOptions})`;
     };
 
-    const typeImports = controllers
-        .map((controller, index) => `import type Controller${index} from ${JSON.stringify(controller.importPath)};`)
-        .join('\n');
-
     const typeLeaf = (leaf: string) => {
-        const meta = getControllerLeafMeta(leaf);
-        const fetcherType = `TControllerFetcher<Controller${meta.controllerIndex}, ${JSON.stringify(meta.methodName)}>`;
+        const meta = JSON.parse(leaf) as
+            | {
+                  rawType: string;
+              }
+            | {
+                  runtimeOnly: true;
+              }
+            | {
+                  hasInput: boolean;
+                  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)}>`;
 
         return meta.hasInput ? `(data: any) => ${fetcherType}` : `() => ${fetcherType}`;
     };
@@ -79,19 +221,19 @@ export const generateControllerArtifacts = () => {
 
 import type ApiClient from '@common/router/request/api';
 import type { TFetcher } from '@common/router/request/api';
-${typeImports ? '\n' + typeImports : ''}
+${[...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>>;
 
-export type TControllers = ${printControllerTree(clientTree, typeLeaf)};
+export type TControllers = ${printControllerTree(typeTree, typeLeaf)};
 
 export const createControllers = (
     api: Pick<ApiClient, 'createFetcher'>
 ): TControllers => (
-${printControllerTree(clientTree, runtimeLeaf)}
+${printControllerTree(runtimeTree, runtimeLeaf)}
 );
 
 export default createControllers;
@@ -106,14 +248,16 @@ export type { TControllers } from '@generated/common/controllers';
 `,
     );
 
-    const controllerImports = controllers
+    const controllerImports = localControllers
         .map((controller, index) => `import Controller${index} from ${JSON.stringify(controller.importPath)};`)
         .join('\n');
 
-    const controllerEntries = controllers.flatMap((controller, controllerIndex) =>
+    const controllerEntries = localControllers.flatMap((controller, controllerIndex) =>
         controller.methods.map(
             (method) => `    {
         path: ${JSON.stringify('/api/' + method.routePath)},
+        filepath: ${JSON.stringify(normalizeAbsolutePath(controller.filepath))},
+        sourceLocation: { line: ${method.sourceLocation.line}, column: ${method.sourceLocation.column} },
         Controller: Controller${controllerIndex},
         method: ${JSON.stringify(method.name)},
     },`,
@@ -134,6 +278,8 @@ ${controllerImports ? '\n' + controllerImports : ''}
 
 export type TGeneratedControllerDefinition = {
     path: string,
+    filepath: string,
+    sourceLocation: { line: number, column: number },
     Controller: new (request: any) => Controller,
     method: string,
 }
@@ -146,5 +292,8 @@ export default controllers;
 `,
     );
 
-    return manifestControllers;
+    return {
+        connectedProjects: connectedProjectContracts,
+        controllers: [...manifestControllers, ...connectedManifestControllers],
+    };
 };

package/cli/compiler/artifacts/discovery.ts

@@ -5,40 +5,6 @@ import ts from 'typescript';
 import app from '../../app';
 import { normalizePath } from './shared';
 
-const ignoredServiceDirectories = new Set(['node_modules', 'proteum']);
-
-export const findServiceDirectories = (dir: string): string[] => {
-    if (!fs.existsSync(dir)) return [];
-
-    const directories: string[] = [];
-
-    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
-        const filePath = path.resolve(dir, dirent.name);
-
-        if (ignoredServiceDirectories.has(dirent.name)) continue;
-
-        let shouldTraverse = false;
-
-        if (dirent.isSymbolicLink()) {
-            const realPath = path.resolve(dir, fs.readlinkSync(filePath));
-            shouldTraverse = fs.lstatSync(realPath).isDirectory();
-        } else if (dirent.isDirectory()) {
-            shouldTraverse = true;
-        }
-
-        if (shouldTraverse) {
-            directories.push(...findServiceDirectories(filePath));
-            continue;
-        }
-
-        if (dirent.name === 'service.json') {
-            directories.push(path.dirname(filePath));
-        }
-    }
-
-    return directories;
-};
-
 const hasRegisteredRouteDefinitions = (filepath: string, content: string) => {
     const sourceFile = ts.createSourceFile(
         filepath,

package/cli/compiler/artifacts/manifest.ts

@@ -1,14 +1,14 @@
+import fs from 'fs';
 import path from 'path';
 
 import app from '../../app';
 import cli from '../..';
-import {
-    inspectProteumEnv,
-} from '../../../common/env/proteumEnv';
+import { inspectProteumEnv } from '../../../common/env/proteumEnv';
 import { reservedRouteSetupKeys, routeSetupOptionKeys } from '../../../common/router/pageSetup';
 import {
     TProteumManifest,
     TProteumManifestCommand,
+    TProteumManifestConnectedProject,
     TProteumManifestController,
     TProteumManifestDiagnostic,
     TProteumManifestLayout,
@@ -16,6 +16,18 @@ import {
 } from '../common/proteumManifest';
 import { writeProteumManifest } from '../common/proteumManifest';
 import { normalizeAbsolutePath, normalizePath } from './shared';
+import type { TResolvedConnectedProjectContract } from './connectedProjects';
+
+const requiredGitignoreEntries = [
+    '/.proteum',
+    '/bin',
+    '/dev',
+    '/.cache',
+    '/var',
+    '/proteum.connected.json',
+] as const;
+
+const normalizeGitignoreEntry = (value: string) => value.trim().replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '');
 
 const collectManifestDiagnostics = ({
     commands,
@@ -206,6 +218,37 @@ const collectManifestDiagnostics = ({
         });
     }
 
+    const gitignoreFilepath = path.join(app.paths.root, '.gitignore');
+
+    if (!fs.existsSync(gitignoreFilepath)) {
+        pushDiagnostic({
+            level: 'warning',
+            code: 'app.gitignore-missing',
+            message: `Missing .gitignore. Proteum generated output should ignore ${requiredGitignoreEntries.join(', ')}.`,
+            filepath: gitignoreFilepath,
+        });
+    } else {
+        const entries = new Set(
+            fs.readFileSync(gitignoreFilepath, 'utf8')
+                .split(/\r?\n/)
+                .map((line) => line.replace(/#.*/, '').trim())
+                .filter(Boolean)
+                .map(normalizeGitignoreEntry),
+        );
+
+        for (const requiredEntry of requiredGitignoreEntries) {
+            const normalizedRequiredEntry = normalizeGitignoreEntry(requiredEntry);
+            if (entries.has(normalizedRequiredEntry)) continue;
+
+            pushDiagnostic({
+                level: 'warning',
+                code: 'app.gitignore-generated-entry-missing',
+                message: `Add "${requiredEntry}" to .gitignore so Proteum generated output stays untracked.`,
+                filepath: gitignoreFilepath,
+            });
+        }
+    }
+
     return diagnostics.sort((a, b) => {
         if (a.level !== b.level) return a.level === 'error' ? -1 : 1;
         if (a.filepath !== b.filepath) return a.filepath.localeCompare(b.filepath);
@@ -218,25 +261,49 @@ const collectManifestDiagnostics = ({
 
 export const writeCurrentProteumManifest = ({
     services,
+    connectedProjects: resolvedConnectedProjects,
     controllers,
     commands,
     routes,
     layouts,
 }: {
     services: TProteumManifest['services'];
+    connectedProjects: TResolvedConnectedProjectContract[];
     controllers: TProteumManifestController[];
     commands: TProteumManifestCommand[];
     routes: TProteumManifest['routes'];
     layouts: TProteumManifestLayout[];
 }) => {
-    const envInspection = inspectProteumEnv(app.paths.root);
+    const envInspection = inspectProteumEnv(app.paths.root, app.connectedProjects);
+    const connectedProjects: TProteumManifestConnectedProject[] = Object.entries(app.connectedProjects)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([namespace, config]) => {
+            const connectedControllers = controllers.filter((controller) => controller.connectedProjectNamespace === namespace);
+            const connectedEnv = app.env.connectedProjects[namespace];
+            const resolvedConnectedProject = resolvedConnectedProjects.find((connectedProject) => connectedProject.namespace === namespace);
+            const contract = resolvedConnectedProject?.contract;
+
+            return {
+                namespace,
+                packageName: contract?.packageName,
+                identityIdentifier: contract?.identity.identifier || connectedControllers[0]?.connectedProjectIdentifier,
+                identityName: contract?.identity.name,
+                sourceKind: resolvedConnectedProject?.sourceKind,
+                sourceValue: resolvedConnectedProject?.sourceValue || config.source,
+                cachedContractFilepath: resolvedConnectedProject?.cachedContractFilepath,
+                typingMode: resolvedConnectedProject?.typingMode,
+                urlInternal: connectedEnv?.urlInternal || config.urlInternal,
+                controllerCount: connectedControllers.length,
+            };
+        });
 
     const manifest: TProteumManifest = {
-        version: 2,
+        version: 9,
         app: {
             root: normalizeAbsolutePath(app.paths.root),
             coreRoot: normalizeAbsolutePath(cli.paths.core.root),
-            identityFilepath: normalizeAbsolutePath(path.join(app.paths.root, 'identity.yaml')),
+            identityFilepath: normalizeAbsolutePath(path.join(app.paths.root, 'identity.config.ts')),
+            setupFilepath: normalizeAbsolutePath(path.join(app.paths.root, 'proteum.config.ts')),
             identity: {
                 name: app.identity.name,
                 identifier: app.identity.identifier,
@@ -249,6 +316,21 @@ export const writeCurrentProteumManifest = ({
                 webDescription: app.identity.web?.description,
                 version: app.identity.web?.version,
             },
+            setup: {
+                transpile: app.transpile.length > 0 ? [...app.transpile] : undefined,
+                connect:
+                    Object.keys(app.connectedProjects).length > 0
+                        ? Object.fromEntries(
+                              Object.entries(app.connectedProjects).map(([namespace, config]) => [
+                                  namespace,
+                                  {
+                                      ...(config.source ? { source: config.source } : {}),
+                                      ...(config.urlInternal ? { urlInternal: config.urlInternal } : {}),
+                                  },
+                              ]),
+                          )
+                        : undefined,
+            },
         },
         conventions: {
             routeSetupOptionKeys: [...routeSetupOptionKeys],
@@ -267,8 +349,10 @@ export const writeCurrentProteumManifest = ({
                 profile: app.env.profile,
                 routerPort: app.env.router.port,
                 routerCurrentDomain: app.env.router.currentDomain,
+                routerInternalUrl: app.env.router.internalUrl,
             },
         },
+        connectedProjects,
         services,
         controllers,
         commands,

package/cli/compiler/artifacts/routing.ts

@@ -100,7 +100,7 @@ const generateClientRouteWrapperModules = () => {
             runtime: 'client',
             side: 'client',
             sourceFilepath: filepath,
-            clientRoute: { chunkId: pageChunk.chunkId, filepath: pageChunk.filepath },
+            clientRoute: { chunkId: pageChunk.chunkId },
             routeSourceFilepaths,
         });
 
@@ -109,7 +109,7 @@ const generateClientRouteWrapperModules = () => {
             runtime: 'server',
             side: 'client',
             sourceFilepath: filepath,
-            clientRoute: { chunkId: pageChunk.chunkId, filepath: pageChunk.filepath },
+            clientRoute: { chunkId: pageChunk.chunkId },
             routeSourceFilepaths,
         });
     }