proteum 2.1.0 → 2.1.2

package/cli/compiler/artifacts/commands.ts

@@ -0,0 +1,217 @@
+import path from 'path';
+import fs from 'fs-extra';
+import ts from 'typescript';
+
+import app from '../../app';
+import cli from '../..';
+import { indexCommands } from '../common/commands';
+import { TProteumManifestCommand } from '../common/proteumManifest';
+import writeIfChanged from '../writeIfChanged';
+import { normalizeAbsolutePath } from './shared';
+
+const readServerTsconfigPaths = () => {
+    const serverTsconfigFilepath = path.join(app.paths.root, 'server', 'tsconfig.json');
+    const parsed = ts.readConfigFile(serverTsconfigFilepath, ts.sys.readFile);
+
+    if (parsed.error) {
+        throw new Error(`Unable to read ${serverTsconfigFilepath}: ${parsed.error.messageText}`);
+    }
+
+    const compilerOptions = (parsed.config?.compilerOptions || {}) as { paths?: Record<string, string[]> };
+
+    return compilerOptions.paths || {};
+};
+
+const createCommandsTsconfigContent = () =>
+    `${JSON.stringify(
+        {
+            extends: '../server/tsconfig.json',
+            compilerOptions: {
+                baseUrl: '..',
+                rootDir: '..',
+                paths: {
+                    ...readServerTsconfigPaths(),
+                    '@/server/index': ['./.proteum/server/commands.app.d.ts'],
+                    '@models/types': ['./.proteum/server/models.ts'],
+                },
+            },
+            include: ['.', '../var/typings', '../node_modules/proteum/types/global', '../.proteum/server/commands.d.ts'],
+        },
+        null,
+        4,
+    )}
+`;
+
+const legacyCommandsTsconfigContent = `{
+    "extends": "../server/tsconfig.json",
+    "include": [
+        ".",
+        "../var/typings",
+        "../node_modules/proteum/types/global",
+        "../.proteum/server/services.d.ts",
+        "../.proteum/server/commands.ts",
+        "../server/index.ts"
+    ]
+}
+`;
+
+const transitionalCommandsTsconfigContent = `{
+    "extends": "../server/tsconfig.json",
+    "include": [
+        ".",
+        "../var/typings",
+        "../node_modules/proteum/types/global",
+        "../.proteum/server/services.d.ts",
+        "../server/index.ts"
+    ]
+}
+`;
+
+const commandsOnlyTsconfigContent = `{
+    "extends": "../server/tsconfig.json",
+    "include": [
+        ".",
+        "../var/typings",
+        "../node_modules/proteum/types/global",
+        "../.proteum/server/commands.d.ts"
+    ]
+}
+`;
+
+const commandsAliasesTsconfigContent = `{
+    "extends": "../server/tsconfig.json",
+    "compilerOptions": {
+        "baseUrl": "..",
+        "rootDir": "..",
+        "paths": {
+            "@/server/index": ["./.proteum/server/commands.app.d.ts"]
+        }
+    },
+    "include": [
+        ".",
+        "../var/typings",
+        "../node_modules/proteum/types/global",
+        "../.proteum/server/commands.d.ts"
+    ]
+}
+`;
+
+const isManagedCommandsTsconfig = (content: string) => {
+    try {
+        const parsed = JSON.parse(content) as {
+            extends?: string;
+            include?: string[];
+            compilerOptions?: { baseUrl?: string; rootDir?: string };
+        };
+
+        if (parsed.extends !== '../server/tsconfig.json') return false;
+        if (JSON.stringify(parsed.include || []) !== JSON.stringify(['.', '../var/typings', '../node_modules/proteum/types/global', '../.proteum/server/commands.d.ts']))
+            return false;
+
+        if (parsed.compilerOptions?.baseUrl !== undefined && parsed.compilerOptions.baseUrl !== '..') return false;
+        if (parsed.compilerOptions?.rootDir !== undefined && parsed.compilerOptions.rootDir !== '..') return false;
+
+        return true;
+    } catch {
+        return false;
+    }
+};
+
+const ensureCommandsTsconfig = () => {
+    const commandsRoot = path.join(app.paths.root, 'commands');
+    const commandsTsconfigFilepath = path.join(commandsRoot, 'tsconfig.json');
+    const nextContent = createCommandsTsconfigContent();
+
+    if (!fs.existsSync(commandsRoot)) return;
+
+    if (!fs.existsSync(commandsTsconfigFilepath)) {
+        writeIfChanged(commandsTsconfigFilepath, nextContent);
+        return;
+    }
+
+    const currentContent = fs.readFileSync(commandsTsconfigFilepath, 'utf8');
+    const generatedContents = new Set([
+        createCommandsTsconfigContent(),
+        legacyCommandsTsconfigContent,
+        transitionalCommandsTsconfigContent,
+        commandsOnlyTsconfigContent,
+        commandsAliasesTsconfigContent,
+    ]);
+
+    if (!generatedContents.has(currentContent) && !isManagedCommandsTsconfig(currentContent)) return;
+
+    writeIfChanged(commandsTsconfigFilepath, nextContent);
+};
+
+export const generateCommandArtifacts = () => {
+    ensureCommandsTsconfig();
+
+    const frameworkCommandsRoot = normalizeAbsolutePath(path.join(cli.paths.core.root, 'commands'));
+    const commands = indexCommands([
+        { importPrefix: `${frameworkCommandsRoot}/`, root: path.join(cli.paths.core.root, 'commands') },
+        { importPrefix: '@/commands/', root: path.join(app.paths.root, 'commands') },
+    ]);
+
+    const getManifestScopeFromImportPath = (importPath: string) =>
+        importPath.startsWith(`${frameworkCommandsRoot}/`) ? 'framework' : 'app';
+
+    const manifestCommands = commands.flatMap<TProteumManifestCommand>((command) =>
+        command.methods.map((method) => ({
+            className: command.className,
+            importPath: command.importPath,
+            filepath: normalizeAbsolutePath(command.filepath),
+            sourceLocation: method.sourceLocation,
+            commandBasePath: command.commandBasePath,
+            methodName: method.name,
+            path: method.path,
+            scope: getManifestScopeFromImportPath(command.importPath),
+        })),
+    );
+
+    const commandImports = commands
+        .map((command, index) => `import Command${index} from ${JSON.stringify(command.importPath)};`)
+        .join('\n');
+
+    const commandEntries = commands.flatMap((command, commandIndex) =>
+        command.methods.map(
+            (method) => `    {
+        path: ${JSON.stringify(method.path)},
+        className: ${JSON.stringify(command.className)},
+        importPath: ${JSON.stringify(command.importPath)},
+        filepath: ${JSON.stringify(normalizeAbsolutePath(command.filepath))},
+        sourceLocation: { line: ${method.sourceLocation.line}, column: ${method.sourceLocation.column} },
+        scope: ${JSON.stringify(getManifestScopeFromImportPath(command.importPath))},
+        Command: Command${commandIndex},
+        methodName: ${JSON.stringify(method.name)},
+    },`,
+        ),
+    );
+
+    writeIfChanged(
+        path.join(app.paths.server.generated, 'commands.ts'),
+        `/*----------------------------------
+- GENERATED FILE
+----------------------------------*/
+
+// This file is generated by Proteum from command files.
+// Do not edit it manually.
+
+import type { Commands } from '@server/app/commands';
+import type { TDevCommandDefinition } from '@common/dev/commands';
+${commandImports ? '\n' + commandImports : ''}
+
+export type TGeneratedCommandDefinition = TDevCommandDefinition & {
+    Command: new (app: any) => Commands<any>,
+    methodName: string,
+}
+
+const commands: TGeneratedCommandDefinition[] = [
+${commandEntries.join('\n')}
+];
+
+export default commands;
+`,
+    );
+
+    return manifestCommands;
+};

package/cli/compiler/artifacts/manifest.ts

@@ -1,12 +1,14 @@
 import path from 'path';
-import fs from 'fs-extra';
-import yaml from 'yaml';
 
 import app from '../../app';
 import cli from '../..';
+import {
+    inspectProteumEnv,
+} from '../../../common/env/proteumEnv';
 import { reservedRouteSetupKeys, routeSetupOptionKeys } from '../../../common/router/pageSetup';
 import {
     TProteumManifest,
+    TProteumManifestCommand,
     TProteumManifestController,
     TProteumManifestDiagnostic,
     TProteumManifestLayout,
@@ -15,24 +17,12 @@ import {
 import { writeProteumManifest } from '../common/proteumManifest';
 import { normalizeAbsolutePath, normalizePath } from './shared';
 
-const envRequiredTopLevelKeys = ['name', 'profile', 'router', 'console'];
-
-const getEnvTopLevelKeys = () => {
-    const envFilepath = path.join(app.paths.root, 'env.yaml');
-
-    if (!fs.existsSync(envFilepath)) return [];
-
-    const rawEnv = yaml.parse(fs.readFileSync(envFilepath, 'utf8'));
-
-    if (!rawEnv || typeof rawEnv !== 'object' || Array.isArray(rawEnv)) return [];
-
-    return Object.keys(rawEnv).sort((a, b) => a.localeCompare(b));
-};
-
 const collectManifestDiagnostics = ({
+    commands,
     controllers,
     routes,
 }: {
+    commands: TProteumManifestCommand[];
     controllers: TProteumManifestController[];
     routes: TProteumManifest['routes'];
 }) => {
@@ -186,6 +176,15 @@ const collectManifestDiagnostics = ({
                 .join(', ')}.`,
     });
 
+    trackDuplicates(commands, (command) => command.path, {
+        code: 'command.duplicate-path',
+        level: 'error',
+        message: (command, others) =>
+            `Duplicate command path "${command.path}" also registered in ${others
+                .map((other) => normalizePath(path.relative(app.paths.root, other.filepath)))
+                .join(', ')}.`,
+    });
+
     const postServerRoutesByPath = new Map(
         routes.server
             .filter((route) => route.methodName === 'post' && !!route.path)
@@ -220,16 +219,20 @@ const collectManifestDiagnostics = ({
 export const writeCurrentProteumManifest = ({
     services,
     controllers,
+    commands,
     routes,
     layouts,
 }: {
     services: TProteumManifest['services'];
     controllers: TProteumManifestController[];
+    commands: TProteumManifestCommand[];
     routes: TProteumManifest['routes'];
     layouts: TProteumManifestLayout[];
 }) => {
+    const envInspection = inspectProteumEnv(app.paths.root);
+
     const manifest: TProteumManifest = {
-        version: 1,
+        version: 2,
         app: {
             root: normalizeAbsolutePath(app.paths.root),
             coreRoot: normalizeAbsolutePath(cli.paths.core.root),
@@ -252,15 +255,26 @@ export const writeCurrentProteumManifest = ({
             reservedRouteSetupKeys: [...reservedRouteSetupKeys],
         },
         env: {
-            sourceFilepath: normalizeAbsolutePath(path.join(app.paths.root, 'env.yaml')),
-            loadedTopLevelKeys: getEnvTopLevelKeys(),
-            requiredTopLevelKeys: [...envRequiredTopLevelKeys],
+            source: 'process.env',
+            loadedVariableKeys: envInspection.loadedVariableKeys,
+            requiredVariables: envInspection.requiredVariables.map((variable) => ({
+                key: variable.key,
+                possibleValues: [...variable.possibleValues],
+                provided: variable.provided,
+            })),
+            resolved: {
+                name: app.env.name,
+                profile: app.env.profile,
+                routerPort: app.env.router.port,
+                routerCurrentDomain: app.env.router.currentDomain,
+            },
         },
         services,
         controllers,
+        commands,
         routes,
         layouts,
-        diagnostics: collectManifestDiagnostics({ controllers, routes }),
+        diagnostics: collectManifestDiagnostics({ commands, controllers, routes }),
     };
 
     writeProteumManifest(app.paths.root, manifest);

package/cli/compiler/artifacts/services.ts

@@ -33,6 +33,14 @@ type TParsedAppBootstrap = {
 };
 
 type TServicesAvailable = Record<string, TServiceMetas>;
+type TCommandServiceStubSource = {
+    aliasImportPath: string;
+    filepath: string;
+};
+type TGeneratedCommandServiceStubs = {
+    declarations: string;
+    typeNamesByAliasImportPath: Map<string, string>;
+};
 
 const buildServicesAvailable = (): TServicesAvailable => {
     const searchDirs = [
@@ -309,6 +317,251 @@ const parseAppBootstrap = (servicesAvailable: TServicesAvailable): TParsedAppBoo
     return { rootServices, routerPlugins };
 };
 
+const commandServiceSearchRoots = [
+    { root: normalizeAbsolutePath(path.join(cli.paths.core.root, 'server', 'services')), prefix: '@server/services/' },
+    { root: normalizeAbsolutePath(path.join(app.paths.root, 'server', 'services')), prefix: '@/server/services/' },
+];
+
+const resolveExistingModuleFilepath = (importPath: string) => {
+    const candidates = [importPath, `${importPath}.ts`, `${importPath}.tsx`, path.join(importPath, 'index.ts'), path.join(importPath, 'index.tsx')];
+
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate)) continue;
+        if (!fs.statSync(candidate).isFile()) continue;
+
+        return normalizeAbsolutePath(candidate);
+    }
+
+    return undefined;
+};
+
+const getCommandServiceAliasFromFilepath = (filepath: string) => {
+    const normalizedFilepath = normalizeAbsolutePath(filepath);
+
+    for (const searchRoot of commandServiceSearchRoots) {
+        if (!normalizedFilepath.startsWith(searchRoot.root + '/')) continue;
+
+        let relativePath = normalizedFilepath.substring(searchRoot.root.length + 1).replace(/\.(ts|tsx)$/, '');
+        if (relativePath.endsWith('/index')) relativePath = relativePath.substring(0, relativePath.length - '/index'.length);
+
+        return searchRoot.prefix + relativePath;
+    }
+
+    return undefined;
+};
+
+const resolveCommandServiceStubSource = (
+    importPath: string,
+    sourceFilepath?: string,
+): TCommandServiceStubSource | undefined => {
+    if (importPath.startsWith('./') || importPath.startsWith('../')) {
+        if (!sourceFilepath) return undefined;
+
+        const resolvedFilepath = resolveExistingModuleFilepath(path.resolve(path.dirname(sourceFilepath), importPath));
+        if (!resolvedFilepath) return undefined;
+
+        const aliasImportPath = getCommandServiceAliasFromFilepath(resolvedFilepath);
+        if (!aliasImportPath) return undefined;
+
+        return { aliasImportPath, filepath: resolvedFilepath };
+    }
+
+    const searchRoot = commandServiceSearchRoots.find((entry) => importPath.startsWith(entry.prefix));
+    if (!searchRoot) return undefined;
+
+    const relativeImportPath = importPath.substring(searchRoot.prefix.length);
+    const resolvedFilepath = resolveExistingModuleFilepath(path.join(searchRoot.root, relativeImportPath));
+    if (!resolvedFilepath) return undefined;
+
+    const aliasImportPath = getCommandServiceAliasFromFilepath(resolvedFilepath);
+    if (!aliasImportPath) return undefined;
+
+    return { aliasImportPath, filepath: resolvedFilepath };
+};
+
+const getCommandServiceStubTypeName = (aliasImportPath: string) =>
+    `ProteumCommandService_${aliasImportPath.replace(/[^A-Za-z0-9_$]+/g, '_')}`;
+
+const isPrivateOrProtectedInstanceMember = (member: ts.ClassElement) =>
+    hasModifier(member, ts.SyntaxKind.PrivateKeyword) ||
+    hasModifier(member, ts.SyntaxKind.ProtectedKeyword) ||
+    hasModifier(member, ts.SyntaxKind.StaticKeyword);
+
+const getPropertyDeclarationType = (
+    property: ts.PropertyDeclaration,
+    imports: Map<string, string>,
+    sourceFilepath: string,
+    getStubTypeName: (source: TCommandServiceStubSource) => string,
+    enqueueStub: (source: TCommandServiceStubSource) => void,
+) => {
+    const initializer = property.initializer ? unwrapExpression(property.initializer) : undefined;
+
+    if (initializer && ts.isNewExpression(initializer)) {
+        if (ts.isIdentifier(initializer.expression)) {
+            const nestedImportPath = imports.get(initializer.expression.text);
+            if (nestedImportPath) {
+                const nestedSource = resolveCommandServiceStubSource(nestedImportPath, sourceFilepath);
+
+                if (nestedSource) {
+                    enqueueStub(nestedSource);
+                    return getStubTypeName(nestedSource);
+                }
+            }
+        }
+    }
+
+    if (!initializer) return 'any';
+    if (ts.isArrayLiteralExpression(initializer)) return 'any[]';
+    if (ts.isObjectLiteralExpression(initializer)) return 'Record<string, any>';
+    if (ts.isStringLiteral(initializer) || ts.isNoSubstitutionTemplateLiteral(initializer)) return 'string';
+    if (ts.isNumericLiteral(initializer)) return 'number';
+    if (initializer.kind === ts.SyntaxKind.TrueKeyword || initializer.kind === ts.SyntaxKind.FalseKeyword) return 'boolean';
+    if (initializer.kind === ts.SyntaxKind.NullKeyword) return 'null';
+
+    return 'any';
+};
+
+const getCommandMethodParameter = (parameter: ts.ParameterDeclaration, index: number) => {
+    const parameterName = ts.isIdentifier(parameter.name) ? parameter.name.text : `arg${index}`;
+
+    if (parameter.dotDotDotToken) return `...${parameterName}: any[]`;
+
+    return `${parameterName}${parameter.questionToken || parameter.initializer ? '?' : ''}: any`;
+};
+
+const isPromiseTypeNode = (typeNode?: ts.TypeNode) =>
+    !!typeNode &&
+    ts.isTypeReferenceNode(typeNode) &&
+    ts.isIdentifier(typeNode.typeName) &&
+    typeNode.typeName.text === 'Promise';
+
+const isArrayLikeTypeNode = (typeNode?: ts.TypeNode): boolean => {
+    if (!typeNode) return false;
+    if (ts.isArrayTypeNode(typeNode)) return true;
+
+    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+        if (typeNode.typeName.text === 'Array' || typeNode.typeName.text === 'ReadonlyArray') return true;
+
+        if (typeNode.typeName.text === 'Promise' && typeNode.typeArguments?.[0]) {
+            return isArrayLikeTypeNode(typeNode.typeArguments[0]);
+        }
+    }
+
+    return false;
+};
+
+const getCommandMethodReturnType = (method: ts.MethodDeclaration) => {
+    const isPromise = hasModifier(method, ts.SyntaxKind.AsyncKeyword) || isPromiseTypeNode(method.type);
+    const containsArrayResult = isArrayLikeTypeNode(method.type);
+
+    if (isPromise && containsArrayResult) return 'Promise<any[]>';
+    if (isPromise) return 'Promise<any>';
+    if (containsArrayResult) return 'any[]';
+
+    return 'any';
+};
+
+const createCommandServiceStubDeclarations = (rootServices: TParsedService[]): TGeneratedCommandServiceStubs => {
+    const stubs = new Map<string, string>();
+    const typeNamesByAliasImportPath = new Map<string, string>();
+    const pendingSources: TCommandServiceStubSource[] = [];
+    const seenSources = new Set<string>();
+    const getStubTypeName = (source: TCommandServiceStubSource) => {
+        const existingTypeName = typeNamesByAliasImportPath.get(source.aliasImportPath);
+        if (existingTypeName) return existingTypeName;
+
+        const typeName = getCommandServiceStubTypeName(source.aliasImportPath);
+        typeNamesByAliasImportPath.set(source.aliasImportPath, typeName);
+
+        return typeName;
+    };
+    const enqueueStub = (source: TCommandServiceStubSource) => {
+        if (seenSources.has(source.aliasImportPath)) return;
+
+        seenSources.add(source.aliasImportPath);
+        pendingSources.push(source);
+    };
+
+    for (const rootService of rootServices) {
+        const source = resolveCommandServiceStubSource(rootService.meta.importationPath);
+        if (source) enqueueStub(source);
+    }
+
+    while (pendingSources.length > 0) {
+        const source = pendingSources.shift()!;
+        const sourceFile = createSourceFile(source.filepath);
+        const imports = buildImportIndex(sourceFile);
+        let defaultClass: ts.ClassDeclaration | undefined;
+
+        try {
+            defaultClass = getDefaultExportClassDeclaration(sourceFile);
+        } catch {
+            defaultClass = undefined;
+        }
+
+        if (!defaultClass) {
+            stubs.set(
+                source.aliasImportPath,
+                `declare class ${getStubTypeName(source)} {
+    app: import("@/server/index").default;
+    [key: string]: any;
+}`,
+            );
+            continue;
+        }
+
+        const className = getStubTypeName(source);
+        const classMembers = [`    app: import("@/server/index").default;`];
+
+        for (const member of defaultClass.members) {
+            if (isPrivateOrProtectedInstanceMember(member)) continue;
+
+            if (ts.isPropertyDeclaration(member)) {
+                const propertyName = getPropertyNameText(member.name);
+                if (!propertyName) continue;
+
+                classMembers.push(
+                    `    ${propertyName}: ${getPropertyDeclarationType(member, imports, source.filepath, getStubTypeName, enqueueStub)};`,
+                );
+                continue;
+            }
+
+            if (ts.isGetAccessorDeclaration(member)) {
+                const propertyName = getPropertyNameText(member.name);
+                if (!propertyName) continue;
+
+                classMembers.push(`    ${propertyName}: any;`);
+                continue;
+            }
+
+            if (ts.isMethodDeclaration(member)) {
+                const methodName = getPropertyNameText(member.name);
+                if (!methodName) continue;
+
+                const parameters = member.parameters.map((parameter, index) => getCommandMethodParameter(parameter, index)).join(', ');
+                const returnType = getCommandMethodReturnType(member);
+
+                classMembers.push(`    ${methodName}(${parameters}): ${returnType};`);
+            }
+        }
+
+        stubs.set(
+            source.aliasImportPath,
+            `declare class ${className} {
+${classMembers.join('\n')}
+}`,
+        );
+    }
+
+    return {
+        declarations: Array.from(stubs.entries())
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([, declaration]) => declaration)
+            .join('\n\n'),
+        typeNamesByAliasImportPath,
+    };
+};
+
 const resolveManifestService = (service: TParsedService, parent: string): TProteumManifestService => ({
     kind: 'service',
     id: service.meta.id,
@@ -329,6 +582,7 @@ export const generateServiceArtifacts = () => {
     const containerServices = app.containerServices.map((serviceName) => "'" + serviceName + "'").join('|');
     const appServices = rootServices.map((service) => resolveManifestService(service, 'app'));
     const routerPluginServices = routerPlugins.map((service) => resolveManifestService(service, 'Router.plugins'));
+    const commandServiceStubs = createCommandServiceStubDeclarations(rootServices);
 
     writeIfChanged(
         path.join(app.paths.client.generated, 'services.d.ts'),
@@ -390,7 +644,15 @@ import type ${appClassIdentifier}Client from '@/client/index';
 
 export type ClientContext = ${appClassIdentifier}Client["Router"]["context"];
 
-export const ReactClientContext = React.createContext<ClientContext>({} as ClientContext);
+type GlobalClientContextStore = typeof globalThis & {
+    __proteumClientContexts?: Record<string, React.Context<ClientContext>>;
+};
+
+const globalClientContextStore = globalThis as GlobalClientContextStore;
+const clientContexts = (globalClientContextStore.__proteumClientContexts ??= {});
+
+export const ReactClientContext =
+    clientContexts['${appClassIdentifier}'] ?? (clientContexts['${appClassIdentifier}'] = React.createContext<ClientContext>({} as ClientContext));
 export default (): ClientContext => React.useContext<ClientContext>(ReactClientContext);`,
     );
 
@@ -411,6 +673,43 @@ declare module '@models/types' {
 
     fs.removeSync(path.join(app.paths.server.generated, 'app.ts'));
 
+    writeIfChanged(
+        path.join(app.paths.server.generated, 'commands.d.ts'),
+        `declare type ${appClassIdentifier} = import("@/server/index").default;
+
+declare module "@models/types" {
+    const Models: any;
+    export = Models;
+}
+
+export {};
+`,
+    );
+
+    writeIfChanged(
+        path.join(app.paths.server.generated, 'commands.app.d.ts'),
+        `${commandServiceStubs.declarations}
+
+declare class ${appClassIdentifier} implements import("@server/app/commands").TCommandApplication {
+    env: import("@server/app/commands").TCommandApplication["env"];
+    identity: import("@server/app/commands").TCommandApplication["identity"];
+    getRootServices: import("@server/app/commands").TCommandApplication["getRootServices"];
+    findService?: import("@server/app/commands").TCommandApplication["findService"];
+    models?: import("@server/app/commands").TCommandApplication["models"];
+    Models?: import("@server/app/commands").TCommandApplication["Models"];
+${rootServices
+    .map((service) => {
+        const typeName = commandServiceStubs.typeNamesByAliasImportPath.get(service.meta.importationPath) || 'any';
+
+        return `    ${service.registeredName}: ${typeName};`;
+    })
+    .join('\n')}
+}
+
+export default ${appClassIdentifier};
+`,
+    );
+
     writeIfChanged(
         path.join(app.paths.server.generated, 'models.ts'),
         `export * from '@/var/prisma/client';