@intuned/runtime 1.0.5 → 1.1.1

package/dist/commands/common/tsNodeImport.js

@@ -3,11 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.tsNodeImport = tsNodeImport;
+exports.tsNodeImport = void 0;
+var _neverthrow = require("neverthrow");
 var _fileUtils = require("./utils/fileUtils");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-async function tsNodeImport(apiName) {
+const tsNodeImport = async apiName => {
   require("ts-node").register({
     transpileOnly: true,
     compilerOptions: {
@@ -15,6 +16,19 @@ async function tsNodeImport(apiName) {
     }
   });
   const path = (0, _fileUtils.getFullPathInProject)(...apiName.split("/"));
-  const imported = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(path);
-  return imported;
-}
+  try {
+    const imported = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(path);
+    return (0, _neverthrow.ok)(imported);
+  } catch (e) {
+    if ("code" in e && e.code === "MODULE_NOT_FOUND") {
+      return (0, _neverthrow.err)({
+        type: "not_found"
+      });
+    }
+    return (0, _neverthrow.err)({
+      type: "other",
+      error: e
+    });
+  }
+};
+exports.tsNodeImport = tsNodeImport;

package/dist/commands/deploy/deploy.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/commands/deploy/deploy.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+
+var _commander = require("commander");
+var _chalk = _interopRequireDefault(require("chalk"));
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _utils = require("./utils");
+var _utils2 = require("../../common/cli/utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+_commander.program.description("Deploy an Intuned project to be public").argument("[project-name]", "Name of the project to deploy").option("-w, --workspace-id <id>", "Your Intuned workspace ID").option("-k, --api-key <key>", "Your Intuned API key").action(async (projectName, options) => {
+  try {
+    const {
+      isValid,
+      errorMessage
+    } = await (0, _utils.validateIntunedProject)();
+    if (!isValid) {
+      const userErrorMesage = `Project to be deployed is not a valid Intuned project: ${errorMessage}, modify and check again`;
+      throw new Error(userErrorMesage);
+    }
+    const _projectName = projectName || (await (0, _utils2.getSettingIntunedJSON)("projectName"));
+    if (!_projectName) {
+      throw new Error("Project name is required");
+    }
+    const projectNameValidation = (0, _utils.validateProjectName)(_projectName);
+    if (!projectNameValidation.isValid) {
+      throw new Error(projectNameValidation.errorMessage);
+    }
+    const auth = await (0, _utils2.getAuthCredentials)(options);
+    const {
+      deployDone,
+      projectId,
+      deployErrorMessage
+    } = await (0, _utils.deployProject)(_projectName, auth);
+    if (!deployDone) {
+      throw new Error(`Project not deployed: ${deployErrorMessage}`);
+    }
+    const url = (0, _utils2.getBaseUrl)();
+    console.log(_chalk.default.green(`\n✅ Project "${_projectName}" deployed successfully!` + `\n\nYou can check your project on the platform: ${_chalk.default.bold(`${url}/projects/${projectId}/details`)}\n`));
+  } catch (error) {
+    console.error(_chalk.default.red(`\n${error.message}`));
+    process.exit(1);
+  }
+});
+_commander.program.parse(process.argv);

package/dist/commands/deploy/utils.d.ts

@@ -0,0 +1,16 @@
+import { AuthCredentials, FileSystemTree } from "../../common/cli/types";
+export declare function convertProjectToCodeTree(projectPath: string): Promise<FileSystemTree>;
+export declare function deployProject(projectName: string, auth: AuthCredentials): Promise<{
+    deployDone: boolean;
+    projectId?: string;
+    deployErrorMessage?: string;
+}>;
+export declare const validateProjectName: (projectName: string) => {
+    isValid: boolean;
+    errorMessage?: string;
+};
+export declare const validateIntunedProject: () => Promise<{
+    isValid: boolean;
+    errorMessage?: string;
+}>;
+export declare const runBuild: () => Promise<boolean>;

package/dist/commands/deploy/utils.js

@@ -0,0 +1,408 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertProjectToCodeTree = convertProjectToCodeTree;
+exports.deployProject = deployProject;
+exports.validateProjectName = exports.validateIntunedProject = exports.runBuild = void 0;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _minimatch = require("minimatch");
+var _zod = require("zod");
+var _child_process = require("child_process");
+var _util = require("util");
+var _projectExclusions = _interopRequireDefault(require("../common/projectExclusions"));
+var _constants = require("../../common/cli/constants");
+var _utils = require("../../common/cli/utils");
+var _utils2 = require("../init/utils");
+var _lodash = require("lodash");
+var _uuid = require("uuid");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const execPromise = (0, _util.promisify)(_child_process.exec);
+function ignoreFilesByPattern(filePath, patterns, projectPath) {
+  const relativePath = path.relative(projectPath, filePath);
+  if (relativePath.startsWith("node_modules")) {
+    return true;
+  }
+  for (const pattern of patterns) {
+    if (!pattern || pattern.startsWith("#")) continue;
+    if (pattern.startsWith("!")) {
+      if ((0, _minimatch.minimatch)(relativePath, pattern.substring(1))) {
+        return false;
+      }
+    } else if ((0, _minimatch.minimatch)(relativePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function listFilesNotIgnored(projectPath, ignorePatterns) {
+  const results = [];
+  function traverseDirectory(dirPath) {
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry);
+        if (ignoreFilesByPattern(fullPath, ignorePatterns, projectPath)) {
+          continue;
+        }
+        try {
+          const stats = fs.statSync(fullPath);
+          if (stats.isDirectory()) {
+            traverseDirectory(fullPath);
+          } else if (stats.isFile()) {
+            results.push(path.relative(projectPath, fullPath));
+          }
+        } catch (error) {
+          console.log(_chalk.default.yellow(`Warning: Could not access ${fullPath}`));
+        }
+      }
+    } catch (error) {
+      console.log(_chalk.default.yellow(`Warning: Could not read directory ${dirPath}`));
+    }
+  }
+  traverseDirectory(projectPath);
+  return results;
+}
+async function convertProjectToCodeTree(projectPath) {
+  const filesToDeploy = listFilesNotIgnored(projectPath, _projectExclusions.default);
+  console.log(_chalk.default.cyan("\nFiles to be deployed:"));
+  const filesToDeployText = "\n  " + filesToDeploy.join("\n  ");
+  console.log(filesToDeployText);
+  function readDirectory(dirPath) {
+    const tree = {};
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry);
+        if (ignoreFilesByPattern(entryPath, _projectExclusions.default, projectPath)) {
+          continue;
+        }
+        try {
+          const stats = fs.statSync(entryPath);
+          if (stats.isFile()) {
+            try {
+              const content = fs.readFileSync(entryPath, "utf-8");
+              tree[entry] = {
+                file: {
+                  contents: content
+                }
+              };
+            } catch (error) {
+              console.log(_chalk.default.yellow(`Warning: Could not read file ${entryPath}`));
+            }
+          } else if (stats.isDirectory()) {
+            const subTree = readDirectory(entryPath);
+            if (Object.keys(subTree).length > 0) {
+              tree[entry] = {
+                directory: subTree
+              };
+            }
+          }
+        } catch (error) {
+          console.log(_chalk.default.yellow(`Warning: Could not access ${entryPath}`));
+        }
+      }
+    } catch (error) {
+      console.log(_chalk.default.yellow(`Warning: Could not read directory ${dirPath}`));
+    }
+    return tree;
+  }
+  console.log(_chalk.default.cyan("\n📦 Building project..."));
+  const tree = readDirectory(projectPath);
+  await mapToIDEParams(tree);
+  return tree;
+}
+async function deployProject(projectName, auth) {
+  const {
+    workspaceId,
+    apiKey
+  } = auth;
+  const baseUrl = (0, _utils.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create`;
+  const headers = {
+    "x-api-key": apiKey,
+    "Content-Type": "application/json"
+  };
+  const projectPath = process.cwd();
+  const codeTree = await convertProjectToCodeTree(projectPath);
+  codeTree["tsconfig.json"] = {
+    file: {
+      contents: JSON.stringify(_constants.tsConfigCli, null, 2)
+    }
+  };
+  const deployProjectPayload = {
+    name: projectName,
+    codeTree,
+    isCli: true,
+    language: "typescript"
+  };
+  const response = await fetch(url, {
+    headers,
+    method: "POST",
+    body: JSON.stringify(deployProjectPayload)
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new Error(`Invalid API key. Please check your API key and try again.`);
+    }
+    throw new Error(`Error deploying project`);
+  }
+  const startTime = Date.now();
+  console.log(_chalk.default.greenBright(`\n🚀 Deploying project...`));
+  return new Promise((resolve, reject) => {
+    const checkInterval = setInterval(async () => {
+      try {
+        const {
+          status,
+          message,
+          projectId
+        } = await checkIntunedProjectDeployStatus(workspaceId, projectName, apiKey);
+        if (status === "completed" || status === "failed" || status === "not_found") {
+          clearInterval(checkInterval);
+          resolve(status === "completed" ? {
+            deployDone: true,
+            projectId
+          } : {
+            deployDone: false,
+            projectId: "",
+            deployErrorMessage: message
+          });
+        }
+        const elapsedTime = Date.now() - startTime;
+        if (elapsedTime > _constants.PROJECT_DEPLOY_TIMEOUT) {
+          clearInterval(checkInterval);
+          reject(new Error(`Deployment timed out after ${Math.floor(_constants.PROJECT_DEPLOY_TIMEOUT / 1000 / 60)} minutes`));
+        }
+      } catch (error) {
+        clearInterval(checkInterval);
+        reject(error);
+      }
+    }, 5000);
+  });
+}
+const validateProjectName = projectName => {
+  const nameSchema = _zod.z.string().min(1, "Project Name is required").max(50, "Name must be 50 characters or less").regex(/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/, "Name can only contain lowercase letters, numbers, hyphens, and underscores in between").refine(value => !_zod.z.string().uuid().safeParse(value).success, {
+    message: "Name cannot be a UUID"
+  });
+  const validation = nameSchema.safeParse(projectName);
+  if (!validation.success) {
+    return {
+      isValid: false,
+      errorMessage: validation.error.errors[0].message
+    };
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateProjectName = validateProjectName;
+const validateIntunedProject = async () => {
+  const currentDirectoryToDeploy = process.cwd();
+  const validationSteps = [{
+    name: "build",
+    check: async () => {
+      try {
+        const buildResult = await runBuild();
+        if (!buildResult) {
+          return {
+            isValid: false,
+            errorMessage: "Build failed"
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Build failed"
+        };
+      }
+    }
+  }, {
+    name: "package.json",
+    check: async () => {
+      try {
+        var _packageJson$dependen;
+        const packageJsonPath = path.join(currentDirectoryToDeploy, "package.json");
+        await fs.exists(packageJsonPath);
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, {
+          encoding: "utf-8"
+        }));
+        const userCodePlaywrightVersion = (_packageJson$dependen = packageJson.dependencies) === null || _packageJson$dependen === void 0 ? void 0 : _packageJson$dependen.playwright;
+        if (userCodePlaywrightVersion !== _constants.CURRENT_PLAYWRIGHT_VERSION) {
+          return {
+            isValid: false,
+            errorMessage: `Playwright version mismatch: expected ${_constants.CURRENT_PLAYWRIGHT_VERSION}, found ${userCodePlaywrightVersion || "none"}`
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Package.json file not found or cannot be read"
+        };
+      }
+    }
+  }, {
+    name: "Intuned.json",
+    check: async () => {
+      try {
+        const intunedJsonPath = path.join(currentDirectoryToDeploy, "Intuned.json");
+        await fs.exists(intunedJsonPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Intuned.json file not found"
+        };
+      }
+    }
+  }, {
+    name: "api folder",
+    check: async () => {
+      try {
+        const apiFolderPath = path.join(currentDirectoryToDeploy, "api");
+        await fs.access(apiFolderPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "API folder not found"
+        };
+      }
+    }
+  }];
+  for (const step of validationSteps) {
+    const result = await step.check();
+    if (!result.isValid) {
+      return result;
+    }
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateIntunedProject = validateIntunedProject;
+const checkIntunedProjectDeployStatus = async (workspaceId, projectName, apiKey) => {
+  try {
+    const baseUrl = (0, _utils.getBaseUrl)();
+    const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create/${projectName}/result`;
+    const headers = {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    };
+    const response = await fetch(url, {
+      headers,
+      method: "GET"
+    });
+    if (response.status === 404) {
+      return {
+        status: "not_found",
+        message: "Project not found"
+      };
+    }
+    if (!response.ok) {
+      throw new Error("Error querying deployment status");
+    }
+    const data = await response.json();
+    if (data.status) {
+      return {
+        status: data.status,
+        message: data.message,
+        projectId: data.projectId
+      };
+    }
+    return {
+      status: "failed",
+      message: `Deployment failed, please try again: ${data.message}`
+    };
+  } catch (e) {
+    throw new Error(`Error during deployment`);
+  }
+};
+const runBuild = async () => {
+  const currentProjectDirectory = process.cwd();
+  console.log(_chalk.default.yellow("Running build..."));
+  const distPath = path.join(currentProjectDirectory, "dist");
+  if (await fs.exists(distPath)) {
+    await fs.remove(distPath);
+  }
+  const buildCommand = "tsc";
+  try {
+    await execPromise(buildCommand, {
+      cwd: currentProjectDirectory
+    });
+    console.log(_chalk.default.green("🏗️ Build completed successfully"));
+    return true;
+  } catch (error) {
+    console.error(_chalk.default.red(`Build failed: ${error.message}`));
+    return false;
+  }
+};
+exports.runBuild = runBuild;
+async function mapToIDEParams(tree) {
+  if (!tree) {
+    return;
+  }
+  if (!tree["parameters"] || (0, _utils2._isFileNode)(tree["parameters"])) {
+    return;
+  }
+  const apiParametersMap = {};
+  const cliParameters = Object.keys(tree["parameters"].directory);
+  const ____testParameters = {
+    directory: {}
+  };
+  for (const parameterKey of cliParameters) {
+    const parameter = tree["parameters"].directory[parameterKey];
+    if ((0, _utils2._isDirectoryNode)(parameter)) {
+      continue;
+    }
+    if ((0, _lodash.isEmpty)(parameter.file.contents)) {
+      continue;
+    }
+    const parameterPayload = JSON.parse(parameter.file.contents);
+    if (!parameterPayload["__api-name"]) {
+      continue;
+    }
+    const api = parameterPayload["__api-name"];
+    const {
+      "__api-name": _,
+      ...parameterValue
+    } = parameterPayload;
+    const testParameter = {
+      name: parameterKey.replace(".json", ""),
+      lastUsed: false,
+      id: (0, _uuid.v4)(),
+      value: JSON.stringify(parameterValue)
+    };
+    if (!apiParametersMap[api]) {
+      apiParametersMap[api] = [];
+    }
+    apiParametersMap[api].push(testParameter);
+  }
+  for (const api in apiParametersMap) {
+    if (apiParametersMap[api].length > 0) {
+      apiParametersMap[api][apiParametersMap[api].length - 1].lastUsed = true;
+    }
+    ____testParameters.directory[`${api}.json`] = {
+      file: {
+        contents: JSON.stringify(apiParametersMap[api], null, 2)
+      }
+    };
+  }
+  delete tree["parameters"];
+  tree["____testParameters"] = ____testParameters;
+  return;
+}

package/dist/commands/init/init.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/commands/init/init.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+"use strict";
+
+var _commander = require("commander");
+var _chalk = _interopRequireDefault(require("chalk"));
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+_commander.program.description("Initialize a new Intuned project from a template").argument("[template-name]", "Name of the template to use").action(async templateName => {
+  try {
+    const template = await (0, _utils.selectTemplate)(templateName);
+    const isTargetDirectoryEmpty = await (0, _utils.checkEmptyDirectory)();
+    await (0, _utils.scaffoldProject)(template, isTargetDirectoryEmpty);
+  } catch (error) {
+    console.error(_chalk.default.red(`\n${error.message}`));
+    process.exit(1);
+  }
+});
+_commander.program.parse(process.argv);

package/dist/commands/init/utils.d.ts

@@ -0,0 +1,11 @@
+import { DirectoryNode, FileNode, FileSystemTree } from "../../common/cli/types";
+export declare function _isDirectoryNode(node: DirectoryNode | FileNode): node is DirectoryNode;
+export declare function _isFileNode(node: DirectoryNode | FileNode): node is FileNode;
+export declare function mountFiles(cwd: string, tree: FileSystemTree): Promise<void>;
+export declare function checkEmptyDirectory(): Promise<boolean>;
+export declare function getAuthCredentials(options: any): {
+    workspaceId: any;
+    apiKey: any;
+};
+export declare function selectTemplate(templateName: any): Promise<any>;
+export declare function scaffoldProject(templateId: string, isTargetDirectoryEmpty: boolean): Promise<void>;