feat: enable deno (#531)

* adding deno reference project and JSRuntime file

* accessing runtime specific functions through JsRuntime

* adding support for both deno.json and deno.jsonc

* no automatic setup for deno projects currently

---------

Co-authored-by: Guy Kedem <[email protected]>
Co-authored-by: Matt Aitken <[email protected]>

Author: 3 people

.vscode/extensions.json

@@ -0,0 +1,9 @@
+{
+	"recommendations": [
+        "astro-build.astro-vscode",
+        "denoland.vscode-deno"
+    ],
+	"unwantedRecommendations": [
+		
+	]
+}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "deno.enablePaths": ["references/deno-reference"]
+}

packages/cli/src/commands/dev.ts

@@ -4,7 +4,7 @@ import childProcess from "child_process";
 import chokidar from "chokidar";
 import fs from "fs/promises";
 import ngrok from "ngrok";
-import { run as ncuRun } from "npm-check-updates";
+import run, { run as ncuRun } from "npm-check-updates";
 import ora, { Ora } from "ora";
 import pRetry, { AbortError } from "p-retry";
 import pathModule from "path";
@@ -22,6 +22,8 @@ import { resolvePath } from "../utils/parseNameAndPath";
 import { RequireKeys } from "../utils/requiredKeys";
 import { Throttle } from "../utils/throttle";
 import { TriggerApi } from "../utils/triggerApi";
+import { standardWatchIgnoreRegex, standardWatchFilePaths } from "../frameworks/watchConfig";
+import { JsRuntime, getJsRuntime } from "../utils/jsRuntime";
 import { wait } from "../utils/wait";
 
 const asyncExecFile = util.promisify(childProcess.execFile);
@@ -45,6 +47,7 @@ const formattedDate = new Intl.DateTimeFormat("en", {
   second: "numeric",
 });
 
+let runtime: JsRuntime;
 export async function devCommand(path: string, anyOptions: any) {
   telemetryClient.dev.started(path, anyOptions);
 
@@ -57,12 +60,12 @@ export async function devCommand(path: string, anyOptions: any) {
   const options = result.data;
 
   const resolvedPath = resolvePath(path);
-
+  runtime = await getJsRuntime(resolvedPath, logger);
   //check for outdated packages, don't await this
-  checkForOutdatedPackages(resolvedPath);
+  runtime.checkForOutdatedPackages();
 
   // Read from package.json to get the endpointId
-  const endpointId = await getEndpointIdFromPackageJson(resolvedPath, options);
+  const endpointId = await getEndpointId(runtime, options);
   if (!endpointId) {
     logger.error(
       "You must run the `init` command first to setup the project – you are missing \n'trigger.dev': { 'endpointId': 'your-client-id' } from your package.json file, or pass in the --client-id option to this command"
@@ -73,8 +76,8 @@ export async function devCommand(path: string, anyOptions: any) {
   logger.success(`✔️ [trigger.dev] Detected TriggerClient id: ${endpointId}`);
 
   //resolve the options using the detected framework (use default if there isn't a matching framework)
-  const packageManager = await getUserPackageManager(resolvedPath);
-  const framework = await getFramework(resolvedPath, packageManager);
+  const packageManager = await runtime.getUserPackageManager();
+  const framework = await runtime.getFramework();
   const resolvedOptions = await resolveOptions(framework, resolvedPath, options);
 
   // Read from .env.local or .env to get the TRIGGER_API_KEY and TRIGGER_API_URL
@@ -170,6 +173,7 @@ async function refresh(options: RefreshOptions) {
     return;
   }
 
+  const refreshedEndpointId = await getEndpointId(runtime, resolvedOptions);
   const { apiKey, apiUrl } = apiDetails;
   const apiClient = new TriggerApi(apiKey, apiUrl);
 
@@ -396,43 +400,10 @@ async function verifyEndpoint(
   return;
 }
 
-export async function checkForOutdatedPackages(path: string) {
-  const updates = (await ncuRun({
-    packageFile: `${path}/package.json`,
-    filter: "/trigger.dev/.+$/",
-    upgrade: false,
-  })) as {
-    [key: string]: string;
-  };
-
-  if (typeof updates === "undefined" || Object.keys(updates).length === 0) {
-    return;
-  }
-
-  const packageFile = await fs.readFile(`${path}/package.json`);
-  const data = JSON.parse(Buffer.from(packageFile).toString("utf8"));
-  const dependencies = data.dependencies;
-  console.log(chalk.bgYellow("Updates available for trigger.dev packages"));
-  console.log(chalk.bgBlue("Run npx @trigger.dev/cli@latest update"));
-
-  for (let dep in updates) {
-    console.log(`${dep}  ${dependencies[dep]}  →  ${updates[dep]}`);
-  }
-}
-
-export async function getEndpointIdFromPackageJson(path: string, options: DevCommandOptions) {
+export function getEndpointId(runtime: JsRuntime, options: DevCommandOptions) {
   if (options.clientId) {
     return options.clientId;
-  }
-
-  const pkgJsonPath = pathModule.join(path, "package.json");
-  const pkgBuffer = await fs.readFile(pkgJsonPath);
-  const pkgJson = JSON.parse(pkgBuffer.toString());
-
-  const value = pkgJson["trigger.dev"]?.endpointId;
-  if (!value || typeof value !== "string") return;
-
-  return value as string;
+  } else return runtime.getEndpointId();
 }
 
 async function resolveEndpointUrl(apiUrl: string, port: number, hostname: string) {

packages/cli/src/commands/init.ts

@@ -22,6 +22,7 @@ import { resolvePath } from "../utils/parseNameAndPath";
 import { readPackageJson } from "../utils/readPackageJson";
 import { renderTitle } from "../utils/renderTitle";
 import { TriggerApi, WhoamiResponse } from "../utils/triggerApi";
+import { getJsRuntime } from "../utils/jsRuntime";
 
 export type InitCommandOptions = {
   projectPath: string;
@@ -38,6 +39,17 @@ export const initCommand = async (options: InitCommandOptions) => {
 
   const resolvedPath = resolvePath(options.projectPath);
 
+  // assuming nodejs by default
+  let runtimeId: string = "nodejs";
+  try {
+    runtimeId = (await getJsRuntime(resolvedPath, logger)).id;
+  } catch {}
+  if (runtimeId !== "nodejs") {
+    logger.error(`We currently only support automatic setup for NodeJS projects.`);
+    telemetryClient.init.failed("not_supported_runtime", options);
+    return;
+  }
+
   await renderTitle(resolvedPath);
 
   if (options.triggerUrl === CLOUD_TRIGGER_URL) {

packages/cli/src/commands/whoami.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { logger } from "../utils/logger";
 import { resolvePath } from "../utils/parseNameAndPath";
 import { TriggerApi } from "../utils/triggerApi";
-import { DevCommandOptions, getEndpointIdFromPackageJson } from "./dev";
+import { DevCommandOptions, getEndpointId } from "./dev";
 import ora from "ora";
 import { getTriggerApiDetails } from "../utils/getTriggerApiDetails";
 
@@ -26,7 +26,7 @@ export async function whoamiCommand(path: string, anyOptions: any) {
   const resolvedPath = resolvePath(path);
 
   // Read from package.json to get the endpointId
-  const endpointId = await getEndpointIdFromPackageJson(resolvedPath, options as DevCommandOptions);
+  const endpointId = await getEndpointId(resolvedPath, options as DevCommandOptions);
   if (!endpointId) {
     logger.error(
       "You must run the `init` command first to setup the project – you are missing \n'trigger.dev': { 'endpointId': 'your-client-id' } from your package.json file, or pass in the --client-id option to this command"

packages/cli/src/utils/jsRuntime.ts

@@ -0,0 +1,136 @@
+import { Framework, getFramework } from "../frameworks";
+import { PackageManager, getUserPackageManager } from "./getUserPkgManager";
+import { Logger } from "./logger";
+import { run as ncuRun } from "npm-check-updates";
+import chalk from "chalk";
+import fs from "fs/promises";
+import pathModule from "path";
+
+export abstract class JsRuntime {
+  logger: Logger;
+  projectRootPath: string;
+  constructor(projectRootPath: string, logger: Logger) {
+    this.logger = logger;
+    this.projectRootPath = projectRootPath;
+  }
+  abstract get id(): string;
+  abstract checkForOutdatedPackages(): Promise<void>;
+  abstract getUserPackageManager(): Promise<PackageManager | undefined>;
+  abstract getFramework(): Promise<Framework | undefined>;
+  abstract getEndpointId(): Promise<string | undefined>;
+}
+
+export async function getJsRuntime(projectRootPath: string, logger: Logger): Promise<JsRuntime> {
+  if (await NodeJsRuntime.isNodeJsRuntime(projectRootPath)) {
+    return new NodeJsRuntime(projectRootPath, logger);
+  } else if (await DenoRuntime.isDenoJsRuntime(projectRootPath)) {
+    return new DenoRuntime(projectRootPath, logger);
+  }
+  throw new Error("Unsupported runtime");
+}
+
+class NodeJsRuntime extends JsRuntime {
+  static async isNodeJsRuntime(projectRootPath: string): Promise<boolean> {
+    try {
+      await fs.stat(pathModule.join(projectRootPath, "package.json"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  get id() {
+    return "nodejs";
+  }
+  get packageJsonPath(): string {
+    return pathModule.join(this.projectRootPath, "package.json");
+  }
+
+  async checkForOutdatedPackages(): Promise<void> {
+    const updates = (await ncuRun({
+      packageFile: `${this.packageJsonPath}`,
+      filter: "/trigger.dev/.+$/",
+      upgrade: false,
+    })) as {
+      [key: string]: string;
+    };
+
+    if (typeof updates === "undefined" || Object.keys(updates).length === 0) {
+      return;
+    }
+
+    const packageFile = await fs.readFile(this.packageJsonPath);
+    const data = JSON.parse(Buffer.from(packageFile).toString("utf8"));
+    const dependencies = data.dependencies;
+    console.log(chalk.bgYellow("Updates available for trigger.dev packages"));
+    console.log(chalk.bgBlue("Run npx @trigger.dev/cli@latest update"));
+
+    for (let dep in updates) {
+      console.log(`${dep}  ${dependencies[dep]}  →  ${updates[dep]}`);
+    }
+  }
+
+  async getUserPackageManager() {
+    return getUserPackageManager(this.projectRootPath);
+  }
+
+  async getFramework() {
+    const userPackageManager = await this.getUserPackageManager();
+    return getFramework(this.projectRootPath, userPackageManager);
+  }
+  async getEndpointId() {
+    const pkgJsonPath = pathModule.join(this.projectRootPath, "package.json");
+    const pkgBuffer = await fs.readFile(pkgJsonPath);
+    const pkgJson = JSON.parse(pkgBuffer.toString());
+    const value = pkgJson["trigger.dev"]?.endpointId;
+    if (!value || typeof value !== "string") return undefined;
+  }
+}
+
+class DenoRuntime extends JsRuntime {
+  getDenoJsonPath(): Promise<string> {
+    try {
+      return fs
+        .stat(pathModule.join(this.projectRootPath, "deno.json"))
+        .then(() => pathModule.join(this.projectRootPath, "deno.json"));
+    } catch {
+      return fs
+        .stat(pathModule.join(this.projectRootPath, "deno.jsonc"))
+        .then(() => pathModule.join(this.projectRootPath, "deno.jsonc"));
+    }
+  }
+
+  get id() {
+    return "deno";
+  }
+
+  static async isDenoJsRuntime(projectRootPath: string): Promise<boolean> {
+    try {
+      try {
+        await fs.stat(pathModule.join(projectRootPath, "deno.json"));
+      } catch (e) {
+        await fs.stat(pathModule.join(projectRootPath, "deno.jsonc"));
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async checkForOutdatedPackages() {
+    // not implemented currently
+  }
+  async getUserPackageManager() {
+    return undefined;
+  }
+  async getFramework() {
+    // not implemented currently
+    return undefined;
+  }
+  async getEndpointId() {
+    const pkgJsonPath = await this.getDenoJsonPath();
+    const pkgBuffer = await fs.readFile(pkgJsonPath);
+    const pkgJson = JSON.parse(pkgBuffer.toString());
+    return pkgJson["trigger.dev"]?.endpointId;
+  }
+}

packages/cli/src/utils/logger.ts

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 
+export type Logger = typeof logger;
 export const logger = {
   error(...args: unknown[]) {
     console.log(chalk.red(...args));

references/deno-reference/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "deno.enable": true
+}

references/deno-reference/deno.json

@@ -0,0 +1,8 @@
+{
+  "trigger.dev": {
+    "endpointId": "borderless" 
+  },
+  "tasks": {
+    "dev": "deno run --watch main.ts"
+  }
+}