@intuned/runtime-dev 0.1.0-test.14 → 0.1.0-test.16

package/dist/common/runApi/index.js

@@ -1,239 +1,247 @@
-import { getDownloadDirectoryPath } from "../../runtime/downloadDirectory";
-import { getExecutionContext } from "../asyncLocalStorage";
-import * as fs from "fs-extra";
-import { backendFunctionsTokenManager } from "../jwtTokenManager";
-import { getContextStorageState, setContextStorageState, } from "../contextStorageStateHelpers";
-import { remove } from "fs-extra";
-import { ok, err } from "neverthrow";
-import { AbortedError, ApiNotFoundError, AutomationError, InvalidApiError, InvalidCheckError, MaxLevelsExceededError, } from "./errors.js";
-import { AUTH_SESSIONS_FOLDER_NAME } from "../constants";
-import { getPlaywrightConstructsForMode, getProductionPlaywrightConstructs, } from "../getPlaywrightConstructs";
-import { runApiParametersSchema, } from "./types.js";
-export * from "./types.js";
-export * from "./errors.js";
-export async function* runApiGenerator({ retrieveSession = false, abortSignal, ...input }) {
-    let traceStarted = false;
-    const { automationFunction, runOptions, tracing, auth, functionsToken } = runApiParametersSchema.parse(input);
-    backendFunctionsTokenManager.token = functionsToken;
-    const downloadsPath = getDownloadDirectoryPath();
-    let page;
-    let context;
-    if (runOptions.environment === "deployed") {
-        const { headless, proxy } = runOptions;
-        ({ page, context } = await getProductionPlaywrightConstructs({
-            headless,
-            proxy,
-            downloadsPath,
-            storageState: auth?.session,
-        }));
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  runApiGenerator: true,
+  runApi: true,
+  checkAuthSessionWithRetries: true
+};
+exports.checkAuthSessionWithRetries = checkAuthSessionWithRetries;
+exports.runApi = runApi;
+exports.runApiGenerator = runApiGenerator;
+var _downloadDirectory = require("../../runtime/downloadDirectory");
+var _asyncLocalStorage = require("../asyncLocalStorage");
+var _fsExtra = _interopRequireWildcard(require("fs-extra"));
+var fs = _fsExtra;
+var _jwtTokenManager = require("../jwtTokenManager");
+var _contextStorageStateHelpers = require("../contextStorageStateHelpers");
+var _neverthrow = require("neverthrow");
+var _errors = require("./errors.js");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _errors[key];
+    }
+  });
+});
+var _constants = require("../constants");
+var _getPlaywrightConstructs = require("../getPlaywrightConstructs");
+var _types = require("./types.js");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+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 && Object.prototype.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* runApiGenerator({
+  retrieveSession = false,
+  abortSignal,
+  ...input
+}) {
+  let traceStarted = false;
+  const {
+    automationFunction,
+    runOptions,
+    tracing,
+    auth,
+    functionsToken
+  } = _types.runApiParametersSchema.parse(input);
+  _jwtTokenManager.backendFunctionsTokenManager.token = functionsToken;
+  const downloadsPath = (0, _downloadDirectory.getDownloadDirectoryPath)();
+  let page;
+  let context;
+  if (runOptions.environment === "deployed") {
+    const {
+      headless,
+      proxy
+    } = runOptions;
+    ({
+      page,
+      context
+    } = await (0, _getPlaywrightConstructs.getProductionPlaywrightConstructs)({
+      headless,
+      proxy,
+      downloadsPath,
+      storageState: auth === null || auth === void 0 ? void 0 : auth.session
+    }));
+  } else {
+    const {
+      mode,
+      cdpAddress
+    } = runOptions;
+    ({
+      page,
+      context
+    } = await (0, _getPlaywrightConstructs.getPlaywrightConstructsForMode)(mode, cdpAddress, auth === null || auth === void 0 ? void 0 : auth.session));
+  }
+  const executionContext = (0, _asyncLocalStorage.getExecutionContext)();
+  if (!executionContext) {
+    throw "";
+  }
+  async function saveTraceIfNeeded({
+    errorMessage
+  }) {
+    if (!tracing.enabled || !traceStarted) {
+      return;
     }
-    else {
-        const { mode, cdpAddress } = runOptions;
-        ({ page, context } = await getPlaywrightConstructsForMode(mode, cdpAddress, auth?.session));
-    }
-    const executionContext = getExecutionContext();
-    if (!executionContext) {
-        throw ""; // todo
-    }
-    async function saveTraceIfNeeded({ errorMessage }) {
-        if (!tracing.enabled || !traceStarted) {
-            return;
-        }
-        try {
-            await context.tracing.stop({ path: tracing.filePath });
-        }
-        catch (error) {
-            console.log(errorMessage, error?.message);
-            await remove(tracing.filePath);
-        }
-    }
-    if (tracing.enabled) {
-        await context.tracing.start({
-            screenshots: true,
-            snapshots: true,
-            sources: true,
-        });
-        traceStarted = true;
-    }
-    const abortSymbol = Symbol("abort");
-    const abortPromise = new Promise((resolve) => {
-        if (!abortSignal)
-            return;
-        abortSignal.addEventListener("abort", () => {
-            resolve(abortSymbol);
-        });
+    try {
+      await context.tracing.stop({
+        path: tracing.filePath
+      });
+    } catch (error) {
+      console.log(errorMessage, error === null || error === void 0 ? void 0 : error.message);
+      await (0, _fsExtra.remove)(tracing.filePath);
+    }
+  }
+  if (tracing.enabled) {
+    await context.tracing.start({
+      screenshots: true,
+      snapshots: true,
+      sources: true
     });
-    if (auth && auth.session.type === "state") {
-        await setContextStorageState(context, auth.session.state);
-    }
-    async function* runAutomation() {
-        if (auth?.runCheck) {
-            if (!auth.session) {
-                return err({ code: "AuthRequiredError" });
-            }
-            console.log("Running auth check");
-            const authCheckResult = await checkAuthSessionWithRetries(page, context, 2);
-            if (authCheckResult.isErr()) {
-                const error = authCheckResult.error;
-                if (["APINotFoundError", "InvalidAPIError"].includes(error.code)) {
-                    return err(new InvalidCheckError(`Auth session check function failed`, error));
-                }
-                return authCheckResult;
-            }
-            if (!authCheckResult.value) {
-                return err({
-                    code: "AuthCheckFailedError",
-                });
-            }
-        }
-        console.log("Running function", automationFunction.name);
-        const args = [
-            ...(automationFunction.params ? [automationFunction.params] : []),
-            page,
-            context,
-        ];
-        const importResult = await importFunction(automationFunction.name);
-        if (importResult.isErr()) {
-            return importResult;
-        }
-        let result;
-        if (importResult.value.type === "async-generator") {
-            const generator = importResult.value.generator(...args);
-            let next = undefined;
-            while (true) {
-                const generatorResult = await generator.next(...(next ? [next] : []));
-                if (!generatorResult.done) {
-                    next = yield generatorResult.value;
-                    continue;
-                }
-                result = generatorResult.value;
-                break;
-            }
-        }
-        else {
-            result = await importResult.value.func(...args);
+    traceStarted = true;
+  }
+  const abortSymbol = Symbol("abort");
+  const abortPromise = new Promise(resolve => {
+    if (!abortSignal) return;
+    abortSignal.addEventListener("abort", () => {
+      resolve(abortSymbol);
+    });
+  });
+  if (auth && auth.session.type === "state") {
+    await (0, _contextStorageStateHelpers.setContextStorageState)(context, auth.session.state);
+  }
+  async function* runAutomation() {
+    var _getExecutionContext;
+    if (auth !== null && auth !== void 0 && auth.runCheck) {
+      if (!auth.session) {
+        return (0, _neverthrow.err)(new _errors.AuthRequiredError());
+      }
+      console.log("Running auth check");
+      const authCheckResult = await checkAuthSessionWithRetries(page, context, 2);
+      if (authCheckResult.isErr()) {
+        const error = authCheckResult.error;
+        if (["APINotFoundError", "InvalidAPIError"].includes(error.code)) {
+          return (0, _neverthrow.err)(new _errors.InvalidCheckError(`Auth session check function failed`, error));
         }
-        return ok({
-            result,
-            extendedPayloads: getExecutionContext()?.extendedPayloads,
-            session: retrieveSession
-                ? await getContextStorageState(context)
-                : undefined,
-        });
-    }
-    try {
-        const generator = runAutomation();
-        let next = undefined;
-        while (true) {
-            const result = await Promise.race([
-                generator.next(await next),
-                abortPromise,
-            ]);
-            if (result === abortSymbol) {
-                return err(new AbortedError());
-            }
-            if (!result.done) {
-                next = yield result.value;
-                continue;
-            }
-            return result.value;
+        return authCheckResult;
+      }
+      if (!authCheckResult.value) {
+        return (0, _neverthrow.err)(new _errors.AuthCheckFailedError());
+      }
+    }
+    const args = [...(automationFunction.params ? [automationFunction.params] : []), page, context];
+    const validatedModuleResult = await validateModule(automationFunction.module);
+    if (validatedModuleResult.isErr()) {
+      return validatedModuleResult;
+    }
+    let result;
+    if (validatedModuleResult.value.type === "async-generator") {
+      const generator = validatedModuleResult.value.generator(...args);
+      let next = undefined;
+      while (true) {
+        const generatorResult = await generator.next(...(next ? [next] : []));
+        if (!generatorResult.done) {
+          next = yield generatorResult.value;
+          continue;
         }
-    }
-    catch (error) {
-        console.log("run errored", error);
-        return err(new AutomationError(error));
-    }
-    finally {
-        await saveTraceIfNeeded({ errorMessage: "failed to save trace" });
-        await context.close();
-        await fs.remove(downloadsPath);
-    }
-}
-export async function runApi(params) {
-    const generator = runApiGenerator(params);
-    const { value, done } = await generator.next();
-    if (done) {
-        return value;
-    }
-    return err(new InvalidApiError("Expected API to be async function, got async generator"));
+        result = generatorResult.value;
+        break;
+      }
+    } else {
+      result = await validatedModuleResult.value.func(...args);
+    }
+    return (0, _neverthrow.ok)({
+      result,
+      extendedPayloads: (_getExecutionContext = (0, _asyncLocalStorage.getExecutionContext)()) === null || _getExecutionContext === void 0 ? void 0 : _getExecutionContext.extendedPayloads,
+      session: retrieveSession ? await (0, _contextStorageStateHelpers.getContextStorageState)(context) : undefined
+    });
+  }
+  try {
+    const generator = runAutomation();
+    let next = undefined;
+    while (true) {
+      const result = await Promise.race([generator.next(await next), abortPromise]);
+      if (result === abortSymbol) {
+        return (0, _neverthrow.err)(new _errors.AbortedError());
+      }
+      if (!result.done) {
+        next = yield result.value;
+        continue;
+      }
+      return result.value;
+    }
+  } catch (error) {
+    console.log("run errored", error);
+    return (0, _neverthrow.err)(new _errors.AutomationError(error));
+  } finally {
+    await saveTraceIfNeeded({
+      errorMessage: "failed to save trace"
+    });
+    await context.close();
+    await fs.remove(downloadsPath);
+  }
 }
-export async function checkAuthSessionWithRetries(page, context, retries = 3) {
-    if (retries === 0) {
-        return ok(false);
-    }
-    let tryNumber = 0;
-    console.log("Checking auth session with retries", `${AUTH_SESSIONS_FOLDER_NAME}/check`);
-    const importResult = await importFunction(`${AUTH_SESSIONS_FOLDER_NAME}/check`);
-    if (importResult.isErr()) {
-        return err(importResult.error);
-    }
-    if (importResult.value.type !== "async") {
-        return err(new InvalidCheckError("Check function is not an async function"));
-    }
-    const check = importResult.value.func;
-    while (retries > tryNumber) {
-        const result = await check(page, context);
-        if (result)
-            return ok(true);
-        tryNumber++;
-    }
-    return ok(false);
+async function runApi(params) {
+  const generator = runApiGenerator(params);
+  const {
+    value,
+    done
+  } = await generator.next();
+  if (done) {
+    return value;
+  }
+  return (0, _neverthrow.err)(new _errors.InvalidApiError("Expected API to be async function, got async generator"));
 }
-async function importFunction(path) {
-    const 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 = undefined;
-        switch (functionNameDepth) {
-            case 1:
-                imported = await import(`../../../${functionNameParts[0]}.ts`);
-                break;
-            case 2:
-                imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}.ts`);
-                break;
-            case 3:
-                imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}.ts`);
-                break;
-            case 4:
-                imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}.ts`);
-                break;
-            case 5:
-                imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}/${functionNameParts[4]}.ts`);
-                break;
-            case 6:
-                imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}/${functionNameParts[4]}/${functionNameParts[5]}.ts`);
-                break;
-            default:
-                return err(new MaxLevelsExceededError(5));
-        }
-        if (!imported || !imported.default || !imported.default.constructor) {
-            return err(new InvalidApiError("API file path does not have a default export"));
-        }
-        if (imported.default.constructor.name === "AsyncGeneratorFunction") {
-            return ok({
-                type: "async-generator",
-                generator: imported.default,
-            });
-        }
-        if (imported.default.constructor.name === "AsyncFunction") {
-            return ok({
-                type: "async",
-                func: imported.default,
-            });
-        }
-        return err(new InvalidApiError("API file path does not have a default async function/generator export"));
-    }
-    catch (error) {
-        if (error.message.includes("Unknown variable dynamic import")) {
-            return err(new ApiNotFoundError(path));
-        }
-        if (error?.code === "ERR_MODULE_NOT_FOUND") {
-            console.log("API not found", error);
-            return err(new ApiNotFoundError(path));
-        }
-        throw error;
-    }
+async function checkAuthSessionWithRetries(page, context, retries = 3) {
+  if (retries === 0) {
+    return (0, _neverthrow.ok)(false);
+  }
+  let tryNumber = 0;
+  console.log("Checking auth session with retries", `${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`);
+  const importResult = await validateModule(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`);
+  if (importResult.isErr()) {
+    return (0, _neverthrow.err)(importResult.error);
+  }
+  if (importResult.value.type !== "async") {
+    return (0, _neverthrow.err)(new _errors.InvalidCheckError("Check function is not an async function"));
+  }
+  const check = importResult.value.func;
+  while (retries > tryNumber) {
+    const result = await check(page, context);
+    if (result) return (0, _neverthrow.ok)(true);
+    tryNumber++;
+  }
+  return (0, _neverthrow.ok)(false);
 }
+async function validateModule(module) {
+  if (!module || !module.default || !module.default.constructor) {
+    return (0, _neverthrow.err)(new _errors.InvalidApiError("API file path does not have a default export"));
+  }
+  if (module.default.constructor.name === "AsyncGeneratorFunction") {
+    return (0, _neverthrow.ok)({
+      type: "async-generator",
+      generator: module.default
+    });
+  }
+  if (module.default.constructor.name === "AsyncFunction") {
+    return (0, _neverthrow.ok)({
+      type: "async",
+      func: module.default
+    });
+  }
+  return (0, _neverthrow.err)(new _errors.InvalidApiError("API file path does not have a default async function/generator export"));
+}

package/dist/common/runApi/types.d.ts

@@ -127,13 +127,23 @@ export declare const runApiSessionSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
 export declare const runApiParametersSchema: z.ZodObject<{
     functionsToken: z.ZodOptional<z.ZodString>;
     automationFunction: z.ZodObject<{
-        name: z.ZodString;
+        module: z.ZodObject<{
+            default: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            default: (...args: unknown[]) => unknown;
+        }, {
+            default: (...args: unknown[]) => unknown;
+        }>;
         params: z.ZodOptional<z.ZodAny>;
     }, "strip", z.ZodTypeAny, {
-        name: string;
+        module: {
+            default: (...args: unknown[]) => unknown;
+        };
         params?: any;
     }, {
-        name: string;
+        module: {
+            default: (...args: unknown[]) => unknown;
+        };
         params?: any;
     }>;
     tracing: z.ZodDefault<z.ZodOptional<z.ZodDiscriminatedUnion<"enabled", [z.ZodObject<{
@@ -360,7 +370,9 @@ export declare const runApiParametersSchema: z.ZodObject<{
     retrieveSession: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     automationFunction: {
-        name: string;
+        module: {
+            default: (...args: unknown[]) => unknown;
+        };
         params?: any;
     };
     tracing: {
@@ -416,7 +428,9 @@ export declare const runApiParametersSchema: z.ZodObject<{
     } | undefined;
 }, {
     automationFunction: {
-        name: string;
+        module: {
+            default: (...args: unknown[]) => unknown;
+        };
         params?: any;
     };
     functionsToken?: string | undefined;

package/dist/common/runApi/types.js

@@ -1,57 +1,54 @@
-import z from "zod";
-export const runApiSessionSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("file"),
-        path: z.string(),
-    }),
-    z.object({
-        type: z.literal("state"),
-        state: z.custom((v) => v),
-    }),
-]);
-export const runApiParametersSchema = z.object({
-    functionsToken: z.string().optional(),
-    automationFunction: z.object({
-        name: z.string(),
-        params: z.any().optional(),
-    }),
-    tracing: z
-        .discriminatedUnion("enabled", [
-        z.object({ enabled: z.literal(false) }),
-        z.object({ enabled: z.literal(true), filePath: z.string() }),
-    ])
-        .optional()
-        .default({ enabled: false }),
-    auth: z
-        .object({
-        session: runApiSessionSchema,
-        runCheck: z.boolean().default(false),
-    })
-        .optional(),
-    runOptions: z
-        .discriminatedUnion("environment", [
-        z.object({
-            environment: z.literal("deployed"),
-            headless: z.boolean().default(true),
-            proxy: z
-                .object({
-                server: z.string(),
-                username: z.string(),
-                password: z.string(),
-            })
-                .optional(),
-        }),
-        z.object({
-            environment: z.literal("ide"),
-            cdpAddress: z.string(),
-            mode: z.union([
-                z.literal("vanilla"),
-                z.literal("playwright"),
-                z.literal("playwright-standalone"),
-                z.literal("playwright-headless"),
-            ]),
-        }),
-    ])
-        .default({ environment: "deployed" }),
-    retrieveSession: z.boolean().default(false),
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
+exports.runApiSessionSchema = exports.runApiParametersSchema = void 0;
+var _zod = _interopRequireDefault(require("zod"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const runApiSessionSchema = exports.runApiSessionSchema = _zod.default.discriminatedUnion("type", [_zod.default.object({
+  type: _zod.default.literal("file"),
+  path: _zod.default.string()
+}), _zod.default.object({
+  type: _zod.default.literal("state"),
+  state: _zod.default.custom(v => v)
+})]);
+const runApiParametersSchema = exports.runApiParametersSchema = _zod.default.object({
+  functionsToken: _zod.default.string().optional(),
+  automationFunction: _zod.default.object({
+    module: _zod.default.object({
+      default: _zod.default.function()
+    }, {
+      required_error: "API handler must have a default export function"
+    }),
+    params: _zod.default.any().optional()
+  }),
+  tracing: _zod.default.discriminatedUnion("enabled", [_zod.default.object({
+    enabled: _zod.default.literal(false)
+  }), _zod.default.object({
+    enabled: _zod.default.literal(true),
+    filePath: _zod.default.string()
+  })]).optional().default({
+    enabled: false
+  }),
+  auth: _zod.default.object({
+    session: runApiSessionSchema,
+    runCheck: _zod.default.boolean().default(false)
+  }).optional(),
+  runOptions: _zod.default.discriminatedUnion("environment", [_zod.default.object({
+    environment: _zod.default.literal("deployed"),
+    headless: _zod.default.boolean().default(true),
+    proxy: _zod.default.object({
+      server: _zod.default.string(),
+      username: _zod.default.string(),
+      password: _zod.default.string()
+    }).optional()
+  }), _zod.default.object({
+    environment: _zod.default.literal("ide"),
+    cdpAddress: _zod.default.string(),
+    mode: _zod.default.union([_zod.default.literal("vanilla"), _zod.default.literal("playwright"), _zod.default.literal("playwright-standalone"), _zod.default.literal("playwright-headless")])
+  })]).default({
+    environment: "deployed"
+  }),
+  retrieveSession: _zod.default.boolean().default(false)
+});