@intuned/runtime-dev 0.1.0-test.37 → 0.1.0-test.4

package/InterfaceTemplate/utils.ts

@@ -1,257 +0,0 @@
-import * as playwright from "@intuned/playwright-core";
-import { Handler, Response } from "@tinyhttp/app";
-import * as path from "path";
-import { getExecutionContext } from "@intuned/runtime";
-import { setTimeout } from "timers/promises";
-
-export class FunctionNotFoundError extends Error {
-  functionName: string;
-  path: string;
-  constructor(functionName: string, path: string) {
-    const message = `function ${functionName} not found in ${path}`;
-    super(message);
-    this.functionName = functionName;
-    this.path = path;
-    this.name = "FunctionNotFound";
-    Object.setPrototypeOf(this, FunctionNotFoundError.prototype);
-  }
-}
-
-export function getIsRetryableError(error: any) {
-  if (error?.message) {
-    return error.message.includes("ERR_NETWORK_CHANGED");
-  }
-  return false;
-}
-
-export function getErrorResponse(error: any): {
-  status: number;
-  body: any;
-} {
-  if (error instanceof FunctionNotFoundError) {
-    return {
-      status: 404,
-      body: {
-        message: error.message,
-        error: error.name,
-      },
-    };
-  }
-  if (error instanceof playwright.errors.TimeoutError) {
-    return {
-      status: 500,
-      body: { message: error.message, error: error.name },
-    };
-  }
-  /**
-   * here we use error.constructor.name instead of error instanceof RunError
-   * this is because the error is thrown by importing the runner from the api code on intuned app
-   * the definition of class RunError which is imported from here is different than the class RunError
-   * imported from the user.
-   */
-  if (error.constructor.name === "RunError") {
-    return {
-      status: 200,
-      body: {
-        status: error.options.status_code ?? 500,
-        message: error.message,
-        error: error.options.error_code ?? error.name,
-        intunedOptions: error.options,
-      },
-    };
-  }
-  return {
-    status: 500,
-    body: { error: error?.name ?? error, message: error?.message },
-  };
-}
-
-export function handlePlaywrightExecutionError(error: any, res: Response) {
-  const { status, body } = getErrorResponse(error);
-  return res.status(status).json(body);
-}
-
-type EventTraceEvent = {
-  type: "event";
-  time: number;
-  class: string;
-  method: string;
-  params: any;
-  pageId?: string;
-};
-
-type AppHandlerParams = Parameters<Handler>;
-
-export function errorRetryMiddleware(handler: Handler) {
-  return async (...args: AppHandlerParams) => {
-    let attempts = 1;
-    const [req, res, next] = args;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      try {
-        await handler(req, res, next);
-        break;
-      } catch (error) {
-        console.log(error?.name, error?.message);
-        if (!getIsRetryableError(error) || attempts >= 3) {
-          return handlePlaywrightExecutionError(error, res);
-        }
-        attempts++;
-      }
-    }
-  };
-}
-
-export function getTraceFilePath(runId: string, attemptNumber?: string) {
-  const fileName = `${runId}${attemptNumber ? `_${attemptNumber}` : ""}`;
-  return path.join(process.env.TRACES_DIRECTORY ?? "", `${fileName}.zip`);
-}
-
-export interface ProxyConfig {
-  username: string;
-  server: string;
-  password: string;
-}
-
-export function proxyToUrl(proxy: ProxyConfig) {
-  const url = new URL(proxy.server);
-  url.username = proxy.username;
-  url.password = proxy.password;
-  return url.toString();
-}
-
-export function isJobRunMachine() {
-  return process.env.JOB_ID && process.env.JOB_RUN_ID;
-}
-
-export function isHeadless() {
-  return process.env.INTUNED_PLAYWRIGHT_HEADLESS !== "0";
-}
-
-export abstract class AsyncRunEndpointController {
-  private static activeRequests: Set<string> = new Set();
-
-  static isRunning(taskToken: string) {
-    return this.activeRequests.has(taskToken);
-  }
-
-  static addRequest(taskToken: string) {
-    this.activeRequests.add(taskToken);
-  }
-
-  static removeRequest(taskToken: string) {
-    this.activeRequests.delete(taskToken);
-  }
-
-  static get activeRequestsCount() {
-    return this.activeRequests.size;
-  }
-}
-
-export async function waitWithExtendableTimeout<T>({
-  initialTimeout,
-  promise,
-  abortController,
-}: {
-  initialTimeout: number;
-  promise: Promise<T>;
-  abortController?: AbortController;
-}): Promise<
-  | {
-      timedOut: true;
-    }
-  | {
-      timedOut: false;
-      result: T;
-    }
-> {
-  const context = getExecutionContext()!;
-  if (context.timeoutInfo) {
-    context.timeoutInfo.timeoutTimestamp = Date.now() + initialTimeout;
-  }
-  const timerSymbol = Symbol("timer");
-  if (!context) {
-    const result = await Promise.race([
-      promise,
-      setTimeout(initialTimeout, timerSymbol),
-    ]);
-    if (result === timerSymbol) {
-      abortController?.abort("Timed out");
-      return { timedOut: true };
-    }
-    return { timedOut: false, result };
-  }
-
-  let taskTimeout = initialTimeout;
-  while (true as boolean) {
-    const result = await Promise.race([
-      promise,
-      setTimeout(taskTimeout, timerSymbol),
-    ]);
-
-    if (result !== timerSymbol) {
-      break;
-    }
-
-    const remainingTime =
-      (context.timeoutInfo?.timeoutTimestamp ?? 0) - Date.now();
-    if (remainingTime < 0) {
-      abortController?.abort("Timed out");
-      return { timedOut: true };
-    }
-
-    taskTimeout = remainingTime;
-  }
-
-  return {
-    timedOut: false,
-    result: await promise,
-  };
-}
-
-export async function importModule(path: string) {
-  const [folderName, ...functionNameParts] = path.split("/");
-  const functionNameDepth = functionNameParts.length;
-
-  // string literals should be inline
-  // currently we support only 5 levels of depth
-  // rollup dynamic import does not support multiple levels of dynamic imports so we need to specify the possible paths explicitly
-  try {
-    let imported: any = undefined;
-    switch (functionNameDepth) {
-      case 1:
-        imported = await import(`./${folderName}/${functionNameParts[0]}.ts`);
-        break;
-      case 2:
-        imported = await import(
-          `./${folderName}/${functionNameParts[0]}/${functionNameParts[1]}.ts`
-        );
-        break;
-      case 3:
-        imported = await import(
-          `./${folderName}/${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}.ts`
-        );
-        break;
-      case 4:
-        imported = await import(
-          `./${folderName}/${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}.ts`
-        );
-        break;
-      case 5:
-        imported = await import(
-          `./${folderName}/${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}/${functionNameParts[4]}.ts`
-        );
-        break;
-      default:
-        throw new Error(
-          "intuned supports maximum 5 levels of depth in the api folder"
-        );
-    }
-    return imported;
-  } catch (error: any) {
-    if (error.message.includes("Unknown variable dynamic import")) {
-      throw new FunctionNotFoundError("", path);
-    }
-    throw error;
-  }
-}

package/dist/commands/common/tsNodeImport.d.ts

@@ -1 +0,0 @@
-export declare function tsNodeImport(apiName: string): Promise<any>;

package/dist/commands/common/utils/template.d.ts

@@ -1,2 +0,0 @@
-export type TemplateName = "WebTemplate" | "InterfaceTemplate";
-export declare const moveTemplateFiles: (templateName: TemplateName) => Promise<void>;

package/dist/common/formatZodError.d.ts

@@ -1,2 +0,0 @@
-import { ZodError } from "zod";
-export declare function formatZodError(zodError: ZodError): string[];

package/dist/common/formatZodError.js

@@ -1,18 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.formatZodError = formatZodError;
-function formatZodError(zodError) {
-  const formattedErrors = zodError.errors.map(error => {
-    const path = error.path.map(segment => {
-      return typeof segment === "number" ? `[${segment}]` : segment;
-    }).join(".");
-    if (path) {
-      return `${path} is invalid - ${error.message}`;
-    }
-    return error.message;
-  });
-  return formattedErrors;
-}