motia 0.5.11-beta.120-382150 → 0.5.11-beta.120-391598

package/dist/cjs/cloud/build/builders/node/index.js

@@ -68,7 +68,10 @@ class NodeBuilder {
     async buildApiSteps(steps) {
         const relativePath = path_1.default.relative(constants_1.distDir, this.builder.projectDir);
         const getStepPath = (step) => {
-            return step.filePath.replace(this.builder.projectDir, relativePath).replace(/(.*)\.(ts|js)$/, '$1.js');
+            return step.filePath
+                .replace(this.builder.projectDir, relativePath)
+                .replace(/(.*)\.(ts|js)$/, '$1.js')
+                .replace(/\\/g, '/');
         };
         const file = fs_1.default
             .readFileSync(path_1.default.join(__dirname, 'router-template.ts'), 'utf-8')

package/dist/cjs/cloud/build/builders/python/index.js

@@ -74,6 +74,7 @@ class PythonBuilder {
             return normalizedEntrypointPath
                 .replace(`${this.builder.projectDir}/`, '')
                 .replace(/(.*)\.py$/, '$1')
+                .replace(/\\/g, '.')
                 .replace(/\//g, '.');
         };
         const zipName = 'router-python.zip';

package/dist/cjs/cloud/endpoints.js

@@ -8,6 +8,7 @@ const build_1 = require("./new-deployment/build");
 const upload_artifacts_1 = require("./new-deployment/upload-artifacts");
 const deployment_stream_1 = require("./new-deployment/streams/deployment-stream");
 const cloud_api_1 = require("./new-deployment/cloud-api");
+const version_1 = require("../version");
 const deployEndpoints = (server, lockedData) => {
     const { app } = server;
     // Criar stream de deployment se não existir
@@ -21,16 +22,20 @@ const deployEndpoints = (server, lockedData) => {
         },
     })();
     const deploymentManager = new deployment_stream_1.DeploymentStreamManager(deploymentStream);
-    app.post('/cloud/deploy/start', async (req, res) => {
+    app.get('/__motia', (_, res) => {
+        res.status(200).json({ version: version_1.version });
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    app.post('/__motia/cloud/deploy/start', async (req, res) => {
         try {
             const { deploymentToken, deploymentId, envs } = req.body;
+            const sessionId = deploymentId || (0, crypto_1.randomUUID)();
             if (!deploymentToken || !deploymentId) {
                 return res.status(400).json({
                     success: false,
                     error: 'deploymentToken and deploymentId are required',
                 });
             }
-            const sessionId = deploymentId || (0, crypto_1.randomUUID)();
             await deploymentManager.startDeployment(sessionId);
             const listener = new streaming_deployment_listener_1.StreamingDeploymentListener(sessionId, deploymentStream);
             res.json({
@@ -44,16 +49,16 @@ const deployEndpoints = (server, lockedData) => {
             setImmediate(async () => {
                 try {
                     await listener.startBuildPhase();
-                    const builder = await (0, build_1.build)(listener);
+                    const builder = await (0, build_1.build)(listener).catch(() => {
+                        throw new Error('Build failed, check the logs for more information');
+                    });
                     const isValid = (0, build_validation_1.buildValidation)(builder, listener);
                     if (!isValid) {
                         await listener.onBuildErrors(listener.getErrors());
                         return;
                     }
-                    await listener.completeBuildPhase();
                     await listener.startUploadPhase();
                     await (0, upload_artifacts_1.uploadArtifacts)(builder, deploymentToken, listener);
-                    await listener.completeUploadPhase();
                     await listener.startDeployPhase();
                     await cloud_api_1.cloudApi.startDeployment({
                         deploymentToken,
@@ -62,6 +67,7 @@ const deployEndpoints = (server, lockedData) => {
                         streams: builder.streamsConfig,
                         routers: builder.routersConfig,
                     });
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 }
                 catch (error) {
                     console.error('Deployment failed:', error);
@@ -71,36 +77,25 @@ const deployEndpoints = (server, lockedData) => {
                     }
                 }
             });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (error) {
             console.error('Failed to start deployment:', error);
-            res.status(500).json({
-                success: false,
-                error: error.message,
-            });
+            res.status(500).json({ success: false, error: error.message });
         }
     });
-    // Get deployment status by ID
-    app.get('/cloud/deploy/status/:deploymentId', async (req, res) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    app.get('/__motia/cloud/deploy/status/:deploymentId', async (req, res) => {
         try {
             const { deploymentId } = req.params;
             const deployment = await deploymentManager.getDeployment(deploymentId);
-            if (!deployment) {
-                return res.status(404).json({
-                    success: false,
-                    error: 'Deployment not found',
-                });
-            }
-            res.json({
-                success: true,
-                deployment,
-            });
+            return deployment
+                ? res.status(200).json({ success: true, deployment })
+                : res.status(404).json({ success: false, error: 'Deployment not found' });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (error) {
-            res.status(500).json({
-                success: false,
-                error: error.message,
-            });
+            res.status(500).json({ success: false, error: error.message });
         }
     });
 };

package/dist/cjs/cloud/new-deployment/listeners/streaming-deployment-listener.d.ts

@@ -10,36 +10,35 @@ export declare class StreamingDeploymentListener implements DeploymentListener {
     private warnings;
     private streamManager;
     constructor(deploymentId: string, deploymentStream: MotiaStream<DeploymentData>);
+    private relativePath;
     private getStepType;
     private getLanguage;
     private updateStream;
     getErrors(): ValidationError[];
-    onBuildStart(step: Step): void;
-    onBuildProgress(step: Step, message: string): void;
-    onBuildEnd(step: Step, size: number): void;
-    onBuildError(step: Step, error: Error): void;
-    onBuildSkip(step: Step, reason: string): void;
-    onStreamCreated(stream: Stream): void;
-    onApiRouterBuilding(language: string): void;
-    onApiRouterBuilt(language: string, size: number): void;
-    onWarning(id: string, warning: string): void;
+    onBuildStart(step: Step): Promise<void>;
+    onBuildProgress(step: Step, message: string): Promise<void>;
+    onBuildEnd(step: Step, size: number): Promise<void>;
+    onBuildError(step: Step, error: Error): Promise<void>;
+    onBuildSkip(step: Step, reason: string): Promise<void>;
+    onStreamCreated(stream: Stream): Promise<void>;
+    onApiRouterBuilding(language: string): Promise<void>;
+    onApiRouterBuilt(language: string, size: number): Promise<void>;
+    onWarning(id: string, warning: string): Promise<void>;
     onBuildWarning(warning: ValidationError): Promise<void>;
     onBuildErrors(errors: ValidationError[]): Promise<void>;
-    stepUploadStart(stepPath: string, step: BuildStepConfig): void;
-    stepUploadProgress(stepPath: string, step: BuildStepConfig, progress: number): void;
-    stepUploadEnd(stepPath: string, step: BuildStepConfig): void;
-    stepUploadError(stepPath: string, step: BuildStepConfig): void;
-    routeUploadStart(path: string, language: string): void;
-    routeUploadProgress(path: string, language: string, progress: number): void;
-    routeUploadEnd(path: string, language: string): void;
-    routeUploadError(path: string, language: string): void;
-    onDeployStart(): void;
-    onDeployProgress(data: DeployData): void;
+    stepUploadStart(stepPath: string, step: BuildStepConfig): Promise<void>;
+    stepUploadProgress(stepPath: string, step: BuildStepConfig, progress: number): Promise<void>;
+    stepUploadEnd(stepPath: string, step: BuildStepConfig): Promise<void>;
+    stepUploadError(stepPath: string, step: BuildStepConfig): Promise<void>;
+    routeUploadStart(path: string, language: string): Promise<void>;
+    routeUploadProgress(path: string, language: string, progress: number): Promise<void>;
+    routeUploadEnd(path: string, language: string): Promise<void>;
+    routeUploadError(path: string, language: string): Promise<void>;
+    onDeployStart(): Promise<void>;
+    onDeployProgress(data: DeployData): Promise<void>;
     onDeployEnd(): Promise<void>;
     onDeployError(errorMessage: string): Promise<void>;
     startBuildPhase(): Promise<void>;
-    completeBuildPhase(): Promise<void>;
     startUploadPhase(): Promise<void>;
-    completeUploadPhase(): Promise<void>;
     startDeployPhase(): Promise<void>;
 }

package/dist/cjs/cloud/new-deployment/listeners/streaming-deployment-listener.js

@@ -9,6 +9,9 @@ class StreamingDeploymentListener {
         this.warnings = [];
         this.streamManager = new deployment_stream_1.DeploymentStreamManager(deploymentStream);
     }
+    relativePath(path) {
+        return path.replace(`${process.cwd()}/`, '');
+    }
     getStepType(step) {
         if (step.config.type === 'api')
             return 'api';
@@ -39,104 +42,83 @@ class StreamingDeploymentListener {
         return this.errors;
     }
     // Build phase events
-    onBuildStart(step) {
+    async onBuildStart(step) {
         const message = `Building step: ${step.config.name}`;
         const buildOutput = {
-            packagePath: step.filePath,
+            packagePath: this.relativePath(step.filePath),
             language: this.getLanguage(step.filePath),
             status: 'building',
             type: this.getStepType(step),
         };
-        this.updateStream({
+        await this.updateStream({
             phase: 'build',
             status: 'building',
             message,
-            progress: 0,
         });
-        this.streamManager.updateBuildOutput(this.deploymentId, buildOutput);
+        await this.streamManager.updateBuildOutput(this.deploymentId, buildOutput);
     }
-    onBuildProgress(step, message) {
+    async onBuildProgress(step, message) {
         const logMessage = `${step.config.name}: ${message}`;
-        this.updateStream({
-            message: logMessage,
-            progress: 25,
-        });
+        await this.updateStream({ message: logMessage });
     }
-    onBuildEnd(step, size) {
+    async onBuildEnd(step, size) {
         const message = `Built ${step.config.name} (${size} bytes)`;
         const buildOutput = {
-            packagePath: step.filePath,
+            packagePath: this.relativePath(step.filePath),
             language: this.getLanguage(step.filePath),
             status: 'built',
             type: this.getStepType(step),
             size,
         };
-        this.updateStream({
-            message,
-            progress: 50,
-        });
-        this.streamManager.updateBuildOutput(this.deploymentId, buildOutput);
+        await this.updateStream({ message });
+        await this.streamManager.updateBuildOutput(this.deploymentId, buildOutput);
     }
-    onBuildError(step, error) {
+    async onBuildError(step, error) {
         const message = `Error building ${step.config.name}: ${error.message}`;
         const buildOutput = {
-            packagePath: step.filePath,
+            packagePath: this.relativePath(step.filePath),
             language: this.getLanguage(step.filePath),
             status: 'error',
             type: this.getStepType(step),
             errorMessage: error.message,
         };
-        this.updateStream({
+        await this.updateStream({
             status: 'failed',
             message,
             error: error.message,
         });
-        this.streamManager.updateBuildOutput(this.deploymentId, buildOutput);
+        await this.streamManager.updateBuildOutput(this.deploymentId, buildOutput);
     }
-    onBuildSkip(step, reason) {
+    async onBuildSkip(step, reason) {
         const message = `Skipped ${step.config.name}: ${reason}`;
-        this.updateStream({
-            message,
-            progress: 10,
-        });
+        await this.updateStream({ message });
     }
-    onStreamCreated(stream) {
+    async onStreamCreated(stream) {
         const message = `Created stream: ${stream.config.name}`;
-        this.updateStream({
-            message,
-            progress: 20,
-        });
+        await this.updateStream({ message });
     }
-    onApiRouterBuilding(language) {
+    async onApiRouterBuilding(language) {
         const message = `Building API router for ${language}`;
-        this.updateStream({
-            message,
-            progress: 60,
-        });
+        await this.updateStream({ message });
     }
-    onApiRouterBuilt(language, size) {
+    async onApiRouterBuilt(language, size) {
         const message = `Built API router for ${language} (${size} bytes)`;
-        this.updateStream({
-            message,
-            progress: 80,
-        });
+        await this.updateStream({ message });
     }
-    onWarning(id, warning) {
+    async onWarning(id, warning) {
         this.warnings.push({
             relativePath: id,
             message: warning,
             step: {},
         });
-        this.updateStream({
+        await this.updateStream({
             message: `Warning: ${warning}`,
-            progress: 10,
         });
     }
     async onBuildWarning(warning) {
         this.warnings.push(warning);
         await this.updateStream({
             message: `Build warning: ${warning.message}`,
-            progress: 10,
         });
     }
     async onBuildErrors(errors) {
@@ -145,28 +127,27 @@ class StreamingDeploymentListener {
         await this.updateStream({
             status: 'failed',
             message: errorMessage,
-            error: errorMessage,
+            error: errors.map((error) => error.message).join('\n'),
         });
     }
     // Upload phase events
-    stepUploadStart(stepPath, step) {
+    async stepUploadStart(stepPath, step) {
         const message = `Starting upload: ${step.config.name}`;
         const uploadOutput = {
-            packagePath: stepPath,
+            packagePath: this.relativePath(stepPath),
             language: this.getLanguage(step.filePath),
             status: 'uploading',
             type: step.config.type,
             progress: 0,
         };
-        this.updateStream({
+        await this.updateStream({
             phase: 'upload',
             status: 'uploading',
             message,
         });
-        this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
+        await this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
     }
-    stepUploadProgress(stepPath, step, progress) {
-        const message = `Uploading ${step.config.name}: ${progress}%`;
+    async stepUploadProgress(stepPath, step, progress) {
         const uploadOutput = {
             packagePath: stepPath,
             language: this.getLanguage(step.filePath),
@@ -174,125 +155,102 @@ class StreamingDeploymentListener {
             type: step.config.type,
             progress,
         };
-        this.updateStream({
-            message,
-            progress,
-        });
-        this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
+        await this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
     }
-    stepUploadEnd(stepPath, step) {
-        const message = `Uploaded: ${step.config.name}`;
+    async stepUploadEnd(stepPath, step) {
         const uploadOutput = {
-            packagePath: stepPath,
+            packagePath: this.relativePath(stepPath),
             language: this.getLanguage(step.filePath),
             status: 'uploaded',
             type: step.config.type,
             progress: 100,
         };
-        this.updateStream({
-            message,
-            progress: 100,
-        });
-        this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
+        await this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
     }
-    stepUploadError(stepPath, step) {
+    async stepUploadError(stepPath, step) {
         const message = `Upload failed: ${step.config.name}`;
         const uploadOutput = {
-            packagePath: stepPath,
+            packagePath: this.relativePath(stepPath),
             language: this.getLanguage(step.filePath),
             status: 'error',
             type: step.config.type,
             errorMessage: message,
         };
-        this.updateStream({
+        await this.updateStream({
             status: 'failed',
             message,
             error: message,
         });
-        this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
+        await this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
     }
-    routeUploadStart(path, language) {
-        const message = `Starting upload: ${language} router`;
+    async routeUploadStart(path, language) {
         const uploadOutput = {
-            packagePath: path,
+            packagePath: this.relativePath(path),
             language,
             status: 'uploading',
             type: 'api',
             progress: 0,
         };
-        this.updateStream({
-            message,
-            progress: 50,
-        });
-        this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
+        await this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
     }
-    routeUploadProgress(path, language, progress) {
-        const message = `Uploading ${language} router: ${progress}%`;
+    async routeUploadProgress(path, language, progress) {
         const uploadOutput = {
-            packagePath: path,
+            packagePath: this.relativePath(path),
             language,
             status: 'uploading',
             type: 'api',
             progress,
         };
-        this.updateStream({
-            message,
-            progress,
-        });
-        this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
+        await this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
     }
-    routeUploadEnd(path, language) {
+    async routeUploadEnd(path, language) {
         const message = `Uploaded: ${language} router`;
         const uploadOutput = {
-            packagePath: path,
+            packagePath: this.relativePath(path),
             language,
             status: 'uploaded',
             type: 'api',
             progress: 100,
         };
-        this.updateStream({
-            message,
-            progress: 100,
-        });
-        this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
+        await this.updateStream({ message });
+        await this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
     }
-    routeUploadError(path, language) {
+    async routeUploadError(path, language) {
         const message = `Upload failed: ${language} router`;
         const uploadOutput = {
-            packagePath: path,
+            packagePath: this.relativePath(path),
             language,
             status: 'error',
             type: 'api',
             errorMessage: message,
         };
-        this.updateStream({
+        await this.updateStream({
             status: 'failed',
             message,
             error: message,
         });
-        this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
+        await this.streamManager.updateUploadOutput(this.deploymentId, uploadOutput);
     }
     // Deploy phase events
-    onDeployStart() {
+    async onDeployStart() {
         const message = 'Deployment started';
-        this.updateStream({
+        await this.updateStream({
             phase: 'deploy',
             status: 'deploying',
             message,
         });
     }
-    onDeployProgress(data) {
+    async onDeployProgress(data) {
         const message = `Deployment status: ${data.status}`;
-        this.updateStream({
+        await this.updateStream({
             message,
-            progress: 50,
         });
     }
     async onDeployEnd() {
-        await this.streamManager.completeDeployment(this.deploymentId, true);
+        await this.streamManager.completeDeployment(this.deploymentId);
     }
     async onDeployError(errorMessage) {
-        await this.streamManager.completeDeployment(this.deploymentId, false, errorMessage);
+        await this.streamManager.completeDeployment(this.deploymentId, errorMessage);
     }
     // Utility methods for phase management
     async startBuildPhase() {
@@ -302,24 +260,11 @@ class StreamingDeploymentListener {
             message: 'Build phase started',
         });
     }
-    async completeBuildPhase() {
-        await this.updateStream({
-            message: 'Build phase completed',
-            progress: 100,
-        });
-    }
     async startUploadPhase() {
         await this.updateStream({
             phase: 'upload',
             status: 'uploading',
             message: 'Upload phase started',
-            progress: 0,
-        });
-    }
-    async completeUploadPhase() {
-        await this.updateStream({
-            message: 'Upload phase completed',
-            progress: 100,
         });
     }
     async startDeployPhase() {
@@ -327,7 +272,6 @@ class StreamingDeploymentListener {
             phase: 'deploy',
             status: 'deploying',
             message: 'Deploy phase started',
-            progress: 0,
         });
     }
 }

package/dist/cjs/cloud/new-deployment/streams/deployment-stream.d.ts

@@ -16,22 +16,22 @@ export type UploadOutput = {
     type: 'event' | 'api' | 'cron';
     errorMessage?: string;
 };
+export type Metadata = {
+    totalSteps?: number;
+    builtSteps?: number;
+    uploadedSteps?: number;
+};
 export interface DeploymentData {
     id: string;
     status: 'idle' | 'building' | 'uploading' | 'deploying' | 'completed' | 'failed';
     phase: 'build' | 'upload' | 'deploy' | null;
-    progress: number;
     message: string;
     build: BuildOutput[];
     upload: UploadOutput[];
     error?: string;
     startedAt?: number;
     completedAt?: number;
-    metadata?: {
-        totalSteps: number;
-        uploadedSteps?: number;
-        buildedSteps?: number;
-    };
+    metadata?: Metadata;
 }
 export declare const createDefaultDeploymentData: (deploymentId: string) => DeploymentData;
 export declare class DeploymentStreamManager {
@@ -40,7 +40,7 @@ export declare class DeploymentStreamManager {
     getDeployment(deploymentId: string): Promise<DeploymentData | null>;
     updateDeployment(deploymentId: string, data: Partial<DeploymentData>): Promise<void>;
     startDeployment(deploymentId: string): Promise<void>;
-    completeDeployment(deploymentId: string, success: boolean, error?: string): Promise<void>;
+    completeDeployment(deploymentId: string, error?: string): Promise<void>;
     updateBuildOutput(deploymentId: string, buildOutput: BuildOutput): Promise<void>;
     updateUploadOutput(deploymentId: string, uploadOutput: UploadOutput): Promise<void>;
 }

package/dist/cjs/cloud/new-deployment/streams/deployment-stream.js

@@ -5,12 +5,13 @@ const createDefaultDeploymentData = (deploymentId) => ({
     id: deploymentId,
     status: 'idle',
     phase: null,
-    progress: 0,
     message: 'No deployment in progress',
     build: [],
     upload: [],
     metadata: {
         totalSteps: 0,
+        builtSteps: 0,
+        uploadedSteps: 0,
     },
 });
 exports.createDefaultDeploymentData = createDefaultDeploymentData;
@@ -51,16 +52,15 @@ class DeploymentStreamManager {
             message: 'Starting deployment...',
         });
     }
-    async completeDeployment(deploymentId, success, error) {
+    async completeDeployment(deploymentId, error) {
         const current = await this.getDeployment(deploymentId);
         if (!current)
             return;
         await this.stream.set(deploymentId, 'data', {
             ...current,
-            status: success ? 'completed' : 'failed',
-            phase: null,
-            progress: 100,
-            message: success ? 'Deployment completed successfully' : `Deployment failed: ${error}`,
+            status: error ? 'failed' : 'completed',
+            phase: error ? current.phase : null,
+            message: error || 'Deployment completed successfully',
             completedAt: Date.now(),
             error,
         });
@@ -77,12 +77,10 @@ class DeploymentStreamManager {
         else {
             updatedBuild.push(buildOutput);
         }
-        // Update buildedSteps count
-        const buildedSteps = updatedBuild.filter(b => b.status === 'built').length;
+        const builtSteps = updatedBuild.filter((b) => b.status === 'built').length;
         const metadata = {
             ...current.metadata,
-            buildedSteps,
-            totalSteps: current.metadata?.totalSteps || updatedBuild.length,
+            builtSteps,
         };
         await this.updateDeployment(deploymentId, { build: updatedBuild, metadata });
     }
@@ -99,11 +97,10 @@ class DeploymentStreamManager {
             updatedUpload.push(uploadOutput);
         }
         // Update uploadedSteps count
-        const uploadedSteps = updatedUpload.filter(u => u.status === 'uploaded').length;
+        const uploadedSteps = updatedUpload.filter((u) => u.status === 'uploaded').length;
         const metadata = {
             ...current.metadata,
             uploadedSteps,
-            totalSteps: current.metadata?.totalSteps || updatedUpload.length,
         };
         await this.updateDeployment(deploymentId, { upload: updatedUpload, metadata });
     }

package/dist/cjs/dev.js

@@ -75,7 +75,7 @@ const dev = async (port, hostname, disableVerbose, enableMermaid) => {
             require('@motiadev/workbench/middleware')
         : // eslint-disable-next-line @typescript-eslint/no-require-imports
             require('@motiadev/workbench/dist/middleware');
-    await applyMiddleware(motiaServer.app);
+    await applyMiddleware(motiaServer.app, port);
     // 6) Gracefully shut down on SIGTERM
     process.on('SIGTERM', async () => {
         (0, core_1.trackEvent)('dev_server_shutdown', { reason: 'SIGTERM' });

package/dist/esm/cloud/build/builders/node/index.js

@@ -29,7 +29,10 @@ export class NodeBuilder {
     async buildApiSteps(steps) {
         const relativePath = path.relative(distDir, this.builder.projectDir);
         const getStepPath = (step) => {
-            return step.filePath.replace(this.builder.projectDir, relativePath).replace(/(.*)\.(ts|js)$/, '$1.js');
+            return step.filePath
+                .replace(this.builder.projectDir, relativePath)
+                .replace(/(.*)\.(ts|js)$/, '$1.js')
+                .replace(/\\/g, '/');
         };
         const file = fs
             .readFileSync(path.join(__dirname, 'router-template.ts'), 'utf-8')