@pipelab/shared 2.0.1-beta.20

package/src/config/projects-types.ts

@@ -0,0 +1,25 @@
+import { SaveLocationValidator } from "../save-location";
+import { object, string, optional, record, InferInput, literal, array } from "valibot";
+
+export const FileRepoValidatorV1 = object({
+  version: literal("1.0.0"),
+  data: optional(record(string(), SaveLocationValidator), {}),
+});
+
+export const FileRepoProjectValidatorV2 = object({
+  id: string(),
+  name: string(),
+  description: string(),
+});
+
+export const FileRepoValidatorV2 = object({
+  version: literal("2.0.0"),
+  projects: array(FileRepoProjectValidatorV2),
+  pipelines: optional(array(SaveLocationValidator), []),
+});
+
+export type FileRepoV1 = InferInput<typeof FileRepoValidatorV1>;
+export type FileRepoV2 = InferInput<typeof FileRepoValidatorV2>;
+
+export const FileRepoValidator = FileRepoValidatorV2;
+export type FileRepo = InferInput<typeof FileRepoValidator>;

package/src/config/projects.ts

@@ -0,0 +1 @@
+export * from "./projects-types";

package/src/config/settings-definition.ts

@@ -0,0 +1,21 @@
+import type {
+  AppConfig,
+  AppConfigV1,
+  AppConfigV2,
+  AppConfigV3,
+  AppConfigV4,
+  AppConfigV5,
+  AppConfigV6,
+  AppConfigV7,
+} from "../config.schema";
+
+export type {
+  AppConfig,
+  AppConfigV1,
+  AppConfigV2,
+  AppConfigV3,
+  AppConfigV4,
+  AppConfigV5,
+  AppConfigV6,
+  AppConfigV7,
+};

package/src/config/settings.ts

@@ -0,0 +1,21 @@
+import type {
+  AppConfig,
+  AppConfigV1,
+  AppConfigV2,
+  AppConfigV3,
+  AppConfigV4,
+  AppConfigV5,
+  AppConfigV6,
+  AppConfigV7,
+} from "../config.schema";
+
+export type {
+  AppConfig,
+  AppConfigV1,
+  AppConfigV2,
+  AppConfigV3,
+  AppConfigV4,
+  AppConfigV5,
+  AppConfigV6,
+  AppConfigV7,
+};

package/src/config.schema.ts

@@ -0,0 +1,149 @@
+import {
+  union,
+  literal,
+  InferInput,
+  string,
+  boolean,
+  object,
+  number,
+  array,
+  GenericSchema,
+} from "valibot";
+
+export const createVersionSchema = <T extends GenericSchema<any, any>>(schema: T) => schema;
+
+export const AppSettingsValidatorV1 = object({
+  cacheFolder: string(),
+  theme: union([literal("light"), literal("dark")]),
+  version: literal("1.0.0"),
+});
+
+export const AppSettingsValidatorV2 = object({
+  cacheFolder: string(),
+  theme: union([literal("light"), literal("dark")]),
+  version: literal("2.0.0"),
+});
+
+export const AppSettingsValidatorV3 = object({
+  cacheFolder: string(),
+  theme: union([literal("light"), literal("dark")]),
+  version: literal("3.0.0"),
+  clearTemporaryFoldersOnPipelineEnd: boolean(),
+});
+
+export const AppSettingsValidatorV4 = object({
+  theme: union([literal("light"), literal("dark")]),
+  version: literal("4.0.0"),
+  cacheFolder: string(),
+  clearTemporaryFoldersOnPipelineEnd: boolean(),
+  locale: union([
+    literal("en-US"),
+    literal("fr-FR"),
+    literal("pt-BR"),
+    literal("zh-CN"),
+    literal("es-ES"),
+    literal("de-DE"),
+  ]),
+});
+
+export const AppSettingsValidatorV5 = object({
+  theme: union([literal("light"), literal("dark")]),
+  version: literal("5.0.0"),
+  cacheFolder: string(),
+  clearTemporaryFoldersOnPipelineEnd: boolean(),
+  locale: union([
+    literal("en-US"),
+    literal("fr-FR"),
+    literal("pt-BR"),
+    literal("zh-CN"),
+    literal("es-ES"),
+    literal("de-DE"),
+  ]),
+  tours: object({
+    dashboard: object({
+      step: number(),
+      completed: boolean(),
+    }),
+    editor: object({
+      step: number(),
+      completed: boolean(),
+    }),
+  }),
+});
+
+export const AppSettingsValidatorV6 = object({
+  theme: union([literal("light"), literal("dark")]),
+  version: literal("6.0.0"),
+  cacheFolder: string(),
+  clearTemporaryFoldersOnPipelineEnd: boolean(),
+  locale: union([
+    literal("en-US"),
+    literal("fr-FR"),
+    literal("pt-BR"),
+    literal("zh-CN"),
+    literal("es-ES"),
+    literal("de-DE"),
+  ]),
+  tours: object({
+    dashboard: object({
+      step: number(),
+      completed: boolean(),
+    }),
+    editor: object({
+      step: number(),
+      completed: boolean(),
+    }),
+  }),
+  autosave: boolean(),
+});
+
+export const AppSettingsValidatorV7 = object({
+  theme: union([literal("light"), literal("dark")]),
+  version: literal("7.0.0"),
+  cacheFolder: string(),
+  clearTemporaryFoldersOnPipelineEnd: boolean(),
+  locale: union([
+    literal("en-US"),
+    literal("fr-FR"),
+    literal("pt-BR"),
+    literal("zh-CN"),
+    literal("es-ES"),
+    literal("de-DE"),
+  ]),
+  tours: object({
+    dashboard: object({
+      step: number(),
+      completed: boolean(),
+    }),
+    editor: object({
+      step: number(),
+      completed: boolean(),
+    }),
+  }),
+  autosave: boolean(),
+  agents: array(
+    object({
+      id: string(),
+      name: string(),
+      url: string(),
+    }),
+  ),
+  buildHistory: object({
+    retentionPolicy: object({
+      enabled: boolean(),
+      maxEntries: number(), // Maximum number of entries per pipeline
+      maxAge: number(), // Maximum age of entries in days
+    }),
+  }),
+});
+
+export type AppConfigV1 = InferInput<typeof AppSettingsValidatorV1>;
+export type AppConfigV2 = InferInput<typeof AppSettingsValidatorV2>;
+export type AppConfigV3 = InferInput<typeof AppSettingsValidatorV3>;
+export type AppConfigV4 = InferInput<typeof AppSettingsValidatorV4>;
+export type AppConfigV5 = InferInput<typeof AppSettingsValidatorV5>;
+export type AppConfigV6 = InferInput<typeof AppSettingsValidatorV6>;
+export type AppConfigV7 = InferInput<typeof AppSettingsValidatorV7>;
+
+export type AppConfig = AppConfigV7;
+export const AppSettingsValidator = AppSettingsValidatorV7;

package/src/database.types.ts

@@ -0,0 +1,95 @@
+export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[];
+
+export type Database = {
+  public: {
+    Tables: {
+      [_ in never]: never;
+    };
+    Views: {
+      [_ in never]: never;
+    };
+    Functions: {
+      [_ in never]: never;
+    };
+    Enums: {
+      [_ in never]: never;
+    };
+    CompositeTypes: {
+      [_ in never]: never;
+    };
+  };
+};
+
+type PublicSchema = Database[Extract<keyof Database, "public">];
+
+export type Tables<
+  PublicTableNameOrOptions extends
+    | keyof (PublicSchema["Tables"] & PublicSchema["Views"])
+    | { schema: keyof Database },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
+    ? keyof (Database[PublicTableNameOrOptions["schema"]]["Tables"] &
+        Database[PublicTableNameOrOptions["schema"]]["Views"])
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof Database }
+  ? (Database[PublicTableNameOrOptions["schema"]]["Tables"] &
+      Database[PublicTableNameOrOptions["schema"]]["Views"])[TableName] extends {
+      Row: infer R;
+    }
+    ? R
+    : never
+  : PublicTableNameOrOptions extends keyof (PublicSchema["Tables"] & PublicSchema["Views"])
+    ? (PublicSchema["Tables"] & PublicSchema["Views"])[PublicTableNameOrOptions] extends {
+        Row: infer R;
+      }
+      ? R
+      : never
+    : never;
+
+export type TablesInsert<
+  PublicTableNameOrOptions extends keyof PublicSchema["Tables"] | { schema: keyof Database },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
+    ? keyof Database[PublicTableNameOrOptions["schema"]]["Tables"]
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof Database }
+  ? Database[PublicTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+      Insert: infer I;
+    }
+    ? I
+    : never
+  : PublicTableNameOrOptions extends keyof PublicSchema["Tables"]
+    ? PublicSchema["Tables"][PublicTableNameOrOptions] extends {
+        Insert: infer I;
+      }
+      ? I
+      : never
+    : never;
+
+export type TablesUpdate<
+  PublicTableNameOrOptions extends keyof PublicSchema["Tables"] | { schema: keyof Database },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
+    ? keyof Database[PublicTableNameOrOptions["schema"]]["Tables"]
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof Database }
+  ? Database[PublicTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+      Update: infer U;
+    }
+    ? U
+    : never
+  : PublicTableNameOrOptions extends keyof PublicSchema["Tables"]
+    ? PublicSchema["Tables"][PublicTableNameOrOptions] extends {
+        Update: infer U;
+      }
+      ? U
+      : never
+    : never;
+
+export type Enums<
+  PublicEnumNameOrOptions extends keyof PublicSchema["Enums"] | { schema: keyof Database },
+  EnumName extends PublicEnumNameOrOptions extends { schema: keyof Database }
+    ? keyof Database[PublicEnumNameOrOptions["schema"]]["Enums"]
+    : never = never,
+> = PublicEnumNameOrOptions extends { schema: keyof Database }
+  ? Database[PublicEnumNameOrOptions["schema"]]["Enums"][EnumName]
+  : PublicEnumNameOrOptions extends keyof PublicSchema["Enums"]
+    ? PublicSchema["Enums"][PublicEnumNameOrOptions]
+    : never;

package/src/errors.ts

@@ -0,0 +1,11 @@
+/**
+ * Defines standardized exit codes for the Pipelab CLI.
+ */
+export enum CLIExitCode {
+  Success = 0,
+  UnknownError = 1,
+  PipelineNotFound = 2,
+  InvalidPipelineFile = 3,
+  PipelineExecutionError = 4,
+  InvalidArguments = 5,
+}

package/src/evaluator.ts

@@ -0,0 +1,58 @@
+import { BlockAction, Steps } from "./model";
+import { createQuickJs, CreateQuickJSFn } from "./quickjs";
+import { useLogger } from "./logger";
+
+export const makeResolvedParams = async (
+  data: {
+    params: BlockAction["params"];
+    steps: Steps;
+    variables: Record<string, string>;
+    context: Record<string, unknown>;
+  },
+  onItem: (item: any) => string = (item: any) => item,
+  _vm?: Awaited<CreateQuickJSFn> | undefined,
+) => {
+  const { logger } = useLogger();
+  const vm = _vm ?? (await createQuickJs());
+
+  const result: Record<string, any> = {};
+
+  const ctx = "createContext" in vm ? (vm as any).createContext() : null;
+
+  for (const [paramName, param] of Object.entries(data.params)) {
+    try {
+      const parameterCodeValue = (param.value ?? "").toString();
+
+      // Bypass QuickJS for simple static values
+      try {
+        result[paramName] = JSON.parse(parameterCodeValue);
+        continue;
+      } catch (e) {
+        // Not a simple JSON value, proceed to QuickJS evaluation
+      }
+
+      const runParams = {
+        steps: data.steps,
+        params: {},
+        variables: data.variables,
+      };
+
+      const output = ctx
+        ? ctx.run(parameterCodeValue, runParams)
+        : await vm.run(parameterCodeValue, runParams);
+
+      const outputResult = onItem(output);
+
+      result[paramName] = outputResult;
+    } catch (e) {
+      logger().error("error", e);
+      result[paramName] = "";
+    }
+  }
+
+  if (ctx) {
+    ctx.dispose();
+  }
+
+  return result;
+};

package/src/fmt.ts

@@ -0,0 +1,5 @@
+export const fmt = {
+  param: (value: string, variant?: "primary" | "secondary" | undefined, ifEmpty: string = "") => {
+    return `<span class="param ${variant ? variant : ""}">${value ? value : ifEmpty}</span>`;
+  },
+};

package/src/graph.ts

@@ -0,0 +1,207 @@
+import { makeResolvedParams } from "./evaluator";
+import { Steps } from "./model";
+import { Variable } from "./variables";
+import { RendererPluginDefinition } from "./plugins/definitions";
+import { Block } from "./model";
+import { Context } from "./types";
+import { End } from "./apis";
+import { useLogger } from "./logger";
+import { variableToFormattedVariable } from "./variables";
+import { createQuickJs } from "./quickjs";
+
+const getPluginDefinition = (pluginId: string, definitions: Array<RendererPluginDefinition>) => {
+  const result = definitions.find((nodeDef) => {
+    return nodeDef.id === pluginId;
+  });
+  return result;
+};
+
+const getNodeDefinition = (
+  nodeId: string,
+  pluginId: string,
+  definitions: Array<RendererPluginDefinition>,
+) => {
+  // const getNodeDefinition = <T extends Block>(node: T extends Block ? T : never) => {
+  const plugin = getPluginDefinition(pluginId, definitions);
+  if (plugin) {
+    return plugin.nodes.find((pluginNode) => pluginNode.node.id === nodeId);
+  }
+  return undefined;
+};
+
+export const processGraph = async (options: {
+  graph: Array<Block>;
+  definitions: Array<RendererPluginDefinition>;
+  // editor user defined variables
+  variables: Array<Variable>;
+  // steps outputs
+  steps: Steps;
+  // context like loopindex
+  context: Context;
+  onExecuteItem: (
+    node: Block,
+    params: Record<string, string>,
+    steps: Steps,
+  ) => Promise<End<"condition:execute"> | End<"action:execute">>;
+  onNodeEnter: (node: Block) => void;
+  onNodeExit: (node: Block) => void;
+  abortSignal?: AbortSignal;
+}) => {
+  const { logger } = useLogger();
+
+  console.log("options.graph", options.graph);
+
+  for (const node of options.graph) {
+    // Check if operation was aborted
+    if (options.abortSignal?.aborted) {
+      const abortError = new Error("Aborted");
+      abortError.name = "AbortError";
+      throw abortError;
+    }
+
+    const rawNode = node;
+
+    const pluginDefinition = getPluginDefinition(node.origin.pluginId, options.definitions);
+    const nodeDefinition = getNodeDefinition(
+      node.origin.nodeId,
+      node.origin.pluginId,
+      options.definitions,
+    );
+
+    /* if (rawNode.type === 'condition') {
+      options.onNodeEnter(rawNode)
+
+      const newParams = await makeResolvedParams({
+        params: rawNode.params,
+        variables: options.variables,
+        steps: options.steps,
+        context: options.context
+      })
+
+      const result = await options.onExecuteItem(node, newParams, options.steps) as End<'condition:execute'>
+
+      if ('result' in result) {
+        logger().error(result.result)
+        options.onNodeExit(rawNode)
+        throw new Error('Condition error')
+      } else {
+        const { value, outputs } = result
+        if (!options.steps[rawNode.uid]) {
+          options.steps[rawNode.uid] = {
+            outputs: {}
+          }
+        }
+        options.steps[rawNode.uid].outputs = outputs
+
+        if (value === true) {
+          await processGraph({
+            graph: rawNode.branchTrue,
+            ...options,
+            abortSignal: options.abortSignal
+          })
+        } else {
+          await processGraph({
+            graph: rawNode.branchFalse,
+            ...options,
+            abortSignal: options.abortSignal
+          })
+        }
+      }
+      options.onNodeExit(rawNode)
+    } else */ if (rawNode.type === "action") {
+      if (rawNode.disabled === true) {
+        console.warn(
+          `Node ${rawNode.uid} (${rawNode.origin.pluginId}::${rawNode.origin.nodeId}) is disabled`,
+        );
+        continue;
+      }
+
+      options.onNodeEnter(rawNode);
+
+      const vm = await createQuickJs();
+
+      const variables = await variableToFormattedVariable(vm, options.variables);
+      console.log("variables", variables);
+
+      const newParams = await makeResolvedParams(
+        {
+          params: rawNode.params,
+          variables,
+          steps: options.steps,
+          context: options.context,
+        },
+        undefined,
+        vm,
+      );
+
+      const result = (await options.onExecuteItem(
+        node,
+        newParams,
+        options.steps,
+      )) as End<"action:execute">;
+
+      if (result.type === "error") {
+        logger().error(result.ipcError);
+        options.onNodeExit(rawNode);
+        // Check if it's an AbortError from cancellation
+        if (
+          result.ipcError &&
+          typeof result.ipcError === "object" &&
+          (result.ipcError as Error).name === "AbortError"
+        ) {
+          throw result.ipcError;
+        }
+        throw new Error(`"${nodeDefinition.node.name}" action error: ${result.ipcError}`);
+      }
+
+      if (result.type === "success") {
+        if (!options.steps[rawNode.uid]) {
+          options.steps[rawNode.uid] = {
+            outputs: {},
+          };
+        }
+        options.steps[rawNode.uid].outputs = result.result.outputs;
+      }
+      options.onNodeExit(rawNode);
+    } else if (rawNode.type === "loop") {
+      options.onNodeEnter(rawNode);
+
+      // const context = {}
+
+      // const arrayToLoopOn = await evaluate(rawNode.params.value, context)
+
+      // element is the value of the element at loopindex
+      // let loopindex = 0
+      // for (const _element of arrayToLoopOn) {
+      //   await processGraph(rawNode.children, definitions, variables, steps, {
+      //     ...context,
+      //     loopindex
+      //   })
+
+      //   loopindex += 1
+      // }
+
+      // continue after loop
+
+      // TODO: process loop
+      // const result = await api.execute('node:execute', {
+      //   nodeId: rawNode.origin.nodeId,
+      //   pluginId: rawNode.origin.pluginId,
+      //   params: rawNode.params
+      // })
+      // console.log('result', result)
+      options.onNodeExit(rawNode);
+    } else if (rawNode.type === "comment") {
+      // pass
+    } else if (rawNode.type === "event") {
+      options.onNodeEnter(rawNode);
+      // pass
+      options.onNodeExit(rawNode);
+    } else {
+      logger().error("Unknown node type", rawNode.type);
+    }
+
+    logger().info("steps", options.steps);
+  }
+  return options;
+};

package/src/i18n/de_DE.json

@@ -0,0 +1,86 @@
+{
+  "settings": {
+    "darkTheme": "Dark theme",
+    "language": "Language",
+    "languageOptions": {
+      "en-US": "English",
+      "fr-FR": "French",
+      "pt-BR": "Portuguese",
+      "zh-CN": "Chinese",
+      "es-ES": "Spanish",
+      "de-DE": "German"
+    },
+    "tabs": {
+      "general": "General",
+      "storage": "Storage",
+      "integrations": "Integrations",
+      "advanced": "Advanced",
+      "billing": "Billing"
+    },
+    "clearTempFolders": "Automatically clean up temporary files",
+    "clearTempFoldersDescription": "Wenn aktiviert, werden alle temporären Dateien, die während der Pipeline-Ausführung erstellt wurden, automatisch gelöscht, nachdem die Pipeline abgeschlossen ist. Dies hilft, Speicherplatz auf der Festplatte zu sparen, aber möglicherweise müssen Sie selbst Artefakte kopieren, um sie zu bewahren.",
+    "pipeline-cache-folder": "Pipeline Cache Folder:",
+    "enter-or-browse-for-a-folder": "Enter or browse for a folder",
+    "browse": "Browse",
+    "manage-where-the-app-stores-temporary-and-cache-files": "Manage where the app stores temporary and cache files.",
+    "clear-cache": "Clear cache",
+    "reset-to-default": "Reset to default",
+    "manage-subscription": "Manage Subscription",
+    "renewal-date": "Renewal Date",
+    "start-date": "Start Date:",
+    "cache-cleared-successfully": "Cache cleared successfully",
+    "failed-to-clear-cache-error-message": "Failed to clear cache: {0}",
+    "failed-to-reset-cache-folder-error-message": "Failed to reset cache folder: {0}",
+    "select-cache-folder": "Select Cache Folder"
+  },
+  "headers": {
+    "dashboard": "Dashboard",
+    "scenarios": "Scenarios",
+    "editor": "Editor",
+    "billing": "Billing",
+    "team": "Team"
+  },
+  "base": {
+    "close": "Schließen",
+    "save": "Speichern",
+    "run": "Ausführen",
+    "cancel": "Abbrechen",
+    "end": "Ende",
+    "delete": "Löschen",
+    "logs": "Protokolle",
+    "ok": "OK",
+    "add": "Hinzufügen"
+  },
+  "editor": {
+    "invalid-file-content": "Invalid file content",
+    "welcome-back": "Welcome back!",
+    "please-log-in-to-run-a-scenario": "Please log in to run a scenario",
+    "execution-done": "Execution done",
+    "your-project-has-been-executed-successfully": "Your project has been executed successfully",
+    "execution-failed": "Execution failed",
+    "project-has-encountered-an-error": "Project has encountered an error:",
+    "project-saved": "Project saved",
+    "your-project-has-be-saved-successfully": "Your project has be saved successfully"
+  },
+  "home": {
+    "invalid-preset": "Invalid preset",
+    "store-project-on-the-cloud": "Store project on the cloud",
+    "cloud": "Cloud",
+    "store-project-locally": "Store project locally",
+    "local": "Local",
+    "invalid-number-of-paths-selected": "Invalid number of paths selected",
+    "pipelab-project": "Pipelab Project",
+    "choose-a-new-path": "Choose a new path",
+    "invalid-file-type": "Invalid file type",
+    "create-project": "Create project",
+    "duplicate-project": "Duplicate project",
+    "project-name": "Project Name",
+    "new-project": "New Project",
+    "open": "Open",
+    "your-projects": "Your projects",
+    "no-projects-yet": "No projects yet"
+  },
+  "scenarios": {
+    "scenarios": "Scenarios"
+  }
+}