@pipelab/shared 1.0.0-beta.3 → 1.0.0-beta.30

package/src/model.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it } from "vitest";
-import { savedFileMigrator, SavedFileV1, SavedFileV2, SavedFileV3 } from "./model";
+import { SavedFileV1, SavedFileV2, SavedFileV3, SavedFileV4, SavedFileV5 } from "./model";
+import {
+  savedFileMigrator,
+  normalizePipelineConfig,
+  appSettingsMigrator,
+  fileRepoMigrations,
+  connectionsMigrator,
+} from "./config/migrators";
+import { AppConfigV6, AppConfigV7 } from "./config.schema";
 
 describe("model", () => {
   it("should migrate 1.0.0 to 2.0.0", async () => {
@@ -211,4 +219,301 @@ describe("model", () => {
       version: "3.0.0",
     } satisfies SavedFileV3);
   });
+
+  it("should migrate 3.0.0 to 4.0.0", async () => {
+    const v3: SavedFileV3 = {
+      version: "3.0.0",
+      canvas: {
+        blocks: [],
+        triggers: [],
+      },
+      description: "desc",
+      name: "name",
+      variables: [],
+    };
+
+    const v4 = await savedFileMigrator.migrate(v3, {
+      debug: true,
+      target: "4.0.0",
+    });
+
+    expect(v4).toStrictEqual({
+      version: "4.0.0",
+      type: "default",
+      canvas: {
+        blocks: [],
+        triggers: [],
+      },
+      description: "desc",
+      name: "name",
+      variables: [],
+    } satisfies SavedFileV4);
+  });
+
+  it("should migrate 4.0.0 to 5.0.0", async () => {
+    const v4: SavedFileV4 = {
+      version: "4.0.0",
+      type: "default",
+      canvas: {
+        blocks: [
+          {
+            uid: "b1",
+            type: "action",
+            origin: {
+              pluginId: "electron",
+              nodeId: "open",
+            },
+            params: {},
+          },
+          {
+            uid: "b2",
+            type: "action",
+            origin: {
+              pluginId: "dicord",
+              nodeId: "send",
+            },
+            params: {},
+          },
+        ],
+        triggers: [],
+      },
+      description: "desc",
+      name: "name",
+      variables: [],
+      plugins: {
+        discord: "1.0.0",
+      },
+    };
+
+    const v5 = await savedFileMigrator.migrate(v4, {
+      debug: true,
+      target: "5.0.0",
+    });
+
+    expect(v5).toStrictEqual({
+      version: "5.0.0",
+      canvas: {
+        blocks: [
+          {
+            uid: "b1",
+            type: "action",
+            origin: {
+              pluginId: "@pipelab/plugin-electron",
+              nodeId: "open",
+              // "electron" wasn't in the old plugins map, so version falls back to "latest"
+              version: "latest",
+            },
+            params: {},
+          },
+          {
+            uid: "b2",
+            type: "action",
+            origin: {
+              pluginId: "@pipelab/plugin-discord",
+              nodeId: "send",
+              // "dicord" mapped to "@pipelab/plugin-discord" which had version "1.0.0" in the old map
+              version: "1.0.0",
+            },
+            params: {},
+          },
+        ],
+        triggers: [],
+      },
+      description: "desc",
+      name: "name",
+      variables: [],
+      // plugins top-level map is dropped in V5 for default pipelines
+    } satisfies SavedFileV5);
+  });
+
+  it("should migrate AppConfigV6 to AppConfigV7", async () => {
+    const v6: AppConfigV6 = {
+      version: "6.0.0",
+      theme: "dark",
+      cacheFolder: "/some/path",
+      clearTemporaryFoldersOnPipelineEnd: true,
+      locale: "fr-FR",
+      tours: {
+        dashboard: { step: 1, completed: true },
+        editor: { step: 2, completed: false },
+      },
+      autosave: false,
+    };
+
+    const v7 = await appSettingsMigrator.migrate(v6, { target: "7.0.0" });
+
+    expect(v7).toStrictEqual({
+      version: "7.0.0",
+      theme: "dark",
+      locale: "fr-FR",
+      tours: {
+        dashboard: { step: 1, completed: true },
+        editor: { step: 2, completed: false },
+      },
+      autosave: false,
+      agents: [],
+      plugins: expect.any(Array),
+      cacheFolder: "/some/path",
+    });
+  });
+
+  describe("normalizePipelineConfig", () => {
+    it("should normalize typo and legacy plugin IDs in block origins", () => {
+      const config = {
+        version: "5.0.0",
+        type: "default",
+        canvas: {
+          blocks: [
+            {
+              uid: "b1",
+              type: "action",
+              origin: {
+                pluginId: "dicord",
+                nodeId: "send",
+              },
+            },
+          ],
+        },
+      };
+
+      const changed = normalizePipelineConfig(config);
+      expect(changed).toBe(true);
+      expect(config.canvas.blocks[0].origin.pluginId).toBe("@pipelab/plugin-discord");
+    });
+  });
+
+  describe("fileRepoMigrations", () => {
+    it("should migrate FileRepoV1 (data record) to FileRepoV3 (pipelines array)", async () => {
+      const v1 = {
+        version: "1.0.0" as const,
+        data: {
+          "pipeline-1": {
+            project: "main",
+            type: "internal" as const,
+            configName: "pipeline-1",
+            lastModified: "2026-06-04",
+          },
+          "pipeline-2": {
+            project: "main",
+            type: "external" as const,
+            path: "/path/to/pipeline-2.json",
+            lastModified: "2026-06-04",
+            summary: {
+              plugins: ["steam"],
+              name: "Test Pipeline 2",
+              description: "Legacy external pipeline",
+            },
+          },
+        },
+      };
+
+      const v3 = await fileRepoMigrations.migrate(v1, { target: "3.0.0" });
+
+      expect(v3).toStrictEqual({
+        version: "3.0.0",
+        data: v1.data,
+        projects: [
+          {
+            id: "main",
+            name: "Default project",
+            description: "The initial default project",
+          },
+        ],
+        pipelines: [
+          {
+            id: "pipeline-1",
+            project: "main",
+            type: "internal",
+            configName: "pipeline-1",
+            lastModified: "2026-06-04",
+          },
+          {
+            id: "pipeline-2",
+            project: "main",
+            type: "external",
+            path: "/path/to/pipeline-2.json",
+            lastModified: "2026-06-04",
+            summary: {
+              plugins: ["steam"],
+              name: "Test Pipeline 2",
+              description: "Legacy external pipeline",
+            },
+          },
+        ],
+      });
+    });
+
+    it("should fallback to default value for corrupted config", async () => {
+      const corrupted: any = {
+        version: "1.0.0",
+        data: null,
+      };
+
+      const result = await fileRepoMigrations.migrate(corrupted, { target: "3.0.0" });
+      expect(result.version).toBe("3.0.0");
+      expect(result.projects).toHaveLength(1);
+      expect(result.pipelines).toEqual([]);
+    });
+  });
+
+  describe("connectionsMigrator", () => {
+    it("should initialize default connections", async () => {
+      const result = await connectionsMigrator.migrate(undefined, { target: "1.0.0" });
+      expect(result).toStrictEqual({
+        version: "1.0.0",
+        connections: [],
+      });
+    });
+  });
+
+  describe("savedFileMigrator - edge cases", () => {
+    it("should normalize unmapped legacy plugin names and typos during migration to 5.0.0", async () => {
+      const v4: SavedFileV4 = {
+        version: "4.0.0",
+        type: "default",
+        canvas: {
+          blocks: [
+            {
+              uid: "b1",
+              type: "action",
+              origin: {
+                pluginId: "filesystem",
+                nodeId: "copy",
+              },
+              params: {},
+            },
+            {
+              uid: "b2",
+              type: "action",
+              origin: {
+                pluginId: "dicord",
+                nodeId: "send",
+              },
+              params: {},
+            },
+            {
+              uid: "b3",
+              type: "action",
+              origin: {
+                pluginId: "custom-cool",
+                nodeId: "run",
+              },
+              params: {},
+            },
+          ],
+          triggers: [],
+        },
+        description: "Edge case plugin names test",
+        name: "Edge Case",
+        variables: [],
+        plugins: {},
+      };
+
+      const v5 = await savedFileMigrator.migrate(v4, { target: "5.0.0" });
+
+      expect(v5.canvas.blocks[0].origin.pluginId).toBe("@pipelab/plugin-filesystem");
+      expect(v5.canvas.blocks[1].origin.pluginId).toBe("@pipelab/plugin-discord");
+      expect(v5.canvas.blocks[2].origin.pluginId).toBe("custom-cool");
+    });
+  });
 });

package/src/model.ts

@@ -32,6 +32,14 @@ export type Position = {
 export const OriginValidator = object({
   pluginId: string(),
   nodeId: string(),
+  version: optional(
+    pipe(
+      string(),
+      description(
+        'Pinned version of the plugin for this block. Falls back to "latest" when absent.',
+      ),
+    ),
+  ),
 });
 
 export type Origin = InferOutput<typeof OriginValidator>;
@@ -49,7 +57,7 @@ export type EditorParam = InferOutput<typeof EditorParamValidatorV3>;
 const BlockActionValidatorV3 = object({
   type: literal("action"),
   uid: string(),
-  name: pipe(optional(string()), description("A custom name provided by the user")),
+  name: optional(pipe(string(), description("A custom name provided by the user"))),
   disabled: optional(boolean()),
   params: record(
     string(),
@@ -61,39 +69,6 @@ const BlockActionValidatorV3 = object({
   origin: OriginValidator,
 });
 
-export type BlockCondition = {
-  type: "condition";
-  uid: string;
-  origin: Origin;
-  params: Record<string, any>;
-  branchTrue: Array<Block>;
-  branchFalse: Array<Block>;
-};
-
-const BlockConditionValidator: GenericSchema<BlockCondition> = object({
-  type: literal("condition"),
-  uid: string(),
-  origin: OriginValidator,
-  params: record(string(), any()),
-  branchTrue: lazy(() => array(BlockValidator)),
-  branchFalse: lazy(() => array(BlockValidator)),
-});
-
-export type BlockLoop = {
-  type: "loop";
-  uid: string;
-  origin: Origin;
-  params: Record<string, any>;
-  children: Array<Block>;
-};
-const BlockLoopValidator: GenericSchema<BlockLoop> = object({
-  type: literal("loop"),
-  uid: string(),
-  origin: OriginValidator,
-  params: record(string(), any()),
-  children: lazy(() => array(BlockValidator)),
-});
-
 const BlockEventValidator = object({
   type: literal("event"),
   uid: string(),
@@ -180,20 +155,22 @@ export const SavedFileValidatorV3 = object({
   variables: array(VariableValidatorV1),
 });
 
-export const SavedFileDefaultValidator = object({
+export const SavedFileDefaultValidatorV4 = object({
   version: literal("4.0.0"),
   type: literal("default"),
   name: string(),
   description: string(),
+  plugins: optional(record(string(), string())),
   canvas: CanvasValidatorV3,
   variables: array(VariableValidatorV1),
 });
 
-export const SavedFileSimpleValidator = object({
+export const SavedFileSimpleValidatorV4 = object({
   version: literal("4.0.0"),
   type: literal("simple"),
   name: string(),
   description: string(),
+  plugins: optional(record(string(), string())),
   source: object({
     type: union([literal("c3-html"), literal("c3-nwjs"), literal("godot"), literal("html")]),
     path: string(),
@@ -208,19 +185,53 @@ export const SavedFileSimpleValidator = object({
   }),
 });
 
-export type SavedFileDefault = InferOutput<typeof SavedFileDefaultValidator>;
-export type SavedFileSimple = InferOutput<typeof SavedFileSimpleValidator>;
-export const SavedFileValidatorV4 = union([SavedFileDefaultValidator, SavedFileSimpleValidator]);
+export const SavedFileDefaultValidatorV5 = object({
+  version: literal("5.0.0"),
+  name: string(),
+  description: string(),
+  canvas: CanvasValidatorV3,
+  variables: array(VariableValidatorV1),
+});
+
+export const SavedFileSimpleValidatorV5 = object({
+  version: literal("5.0.0"),
+  type: literal("simple"),
+  name: string(),
+  description: string(),
+  plugins: record(string(), string()),
+  source: object({
+    type: union([literal("c3-html"), literal("c3-nwjs"), literal("godot"), literal("html")]),
+    path: string(),
+  }),
+  packaging: object({
+    enabled: boolean(),
+  }),
+  publishing: object({
+    steam: object({ enabled: boolean(), appId: optional(string()) }),
+    itch: object({ enabled: boolean(), project: optional(string()) }),
+    poki: object({ enabled: boolean(), gameId: optional(string()) }),
+  }),
+});
+
+export type SavedFileDefault = InferOutput<typeof SavedFileDefaultValidatorV5>;
+export type SavedFileSimple = InferOutput<typeof SavedFileSimpleValidatorV5>;
+
+export const SavedFileValidatorV4 = union([
+  SavedFileDefaultValidatorV4,
+  SavedFileSimpleValidatorV4,
+]);
+export const SavedFileValidatorV5 = SavedFileDefaultValidatorV5;
 
 export type SavedFileV1 = InferOutput<typeof SavedFileValidatorV1>;
 export type SavedFileV2 = InferOutput<typeof SavedFileValidatorV2>;
 export type SavedFileV3 = InferOutput<typeof SavedFileValidatorV3>;
 export type SavedFileV4 = InferOutput<typeof SavedFileValidatorV4>;
-export type SavedFile = SavedFileV4;
-export const SavedFileValidator = SavedFileValidatorV4;
+export type SavedFileV5 = InferOutput<typeof SavedFileValidatorV5>;
+export type SavedFile = SavedFileV5;
+export const SavedFileValidator = SavedFileValidatorV5;
 
 export type Preset = SavedFile;
-export type PresetResult = { data: SavedFile; hightlight?: boolean; disabled?: boolean };
+export type PresetResult = { data: Preset; hightlight?: boolean; disabled?: boolean };
 export type PresetFn = () => Promise<PresetResult>;
 
 export type Steps = Record<
@@ -230,4 +241,4 @@ export type Steps = Record<
   }
 >;
 
-export type EnhancedFile<T extends SavedFile = SavedFile> = WithId<SaveLocation> & { content: T };
+export type EnhancedFile<T = SavedFile> = WithId<SaveLocation> & { content: T };

package/src/plugins/definitions.ts

@@ -79,6 +79,7 @@ export interface ControlTypePath extends ControlTypeBase {
   type: "path";
   options: OpenDialogOptions;
   label?: string;
+  warnIfBlacklisted?: boolean;
 }
 
 export interface ControlTypeJSON extends ControlTypeBase {
@@ -154,18 +155,36 @@ export type IconType =
       icon: string;
     };
 export interface PluginDefinition {
-  id: string;
-  name: string;
-  icon: IconType;
-  description: string;
+  packageName?: string;
+  version?: string;
 }
 
 export type RendererNodeDefinition = {
   node: PipelabNode;
 };
 
+export interface IntegrationField {
+  key: string;
+  label: string;
+  type: "text" | "password" | "file" | "directory";
+  placeholder?: string;
+}
+
+export interface IntegrationDefinition {
+  name: string;
+  fields: IntegrationField[];
+}
+
 export interface RendererPluginDefinition extends PluginDefinition {
+  id: string;
+  name: string;
+  icon: IconType;
+  description: string;
+  isOfficial: boolean;
+  packageName: string;
+  version: string;
   nodes: Array<RendererNodeDefinition>;
+  integrations?: Array<IntegrationDefinition>;
 }
 
 export interface MainPluginDefinition extends PluginDefinition {
@@ -177,6 +196,7 @@ export interface MainPluginDefinition extends PluginDefinition {
     description: string;
     validator: (options: any) => any;
   }>;
+  integrations?: Array<IntegrationDefinition>;
 }
 
 export const createNodeDefinition = (def: MainPluginDefinition) => {
@@ -203,10 +223,7 @@ export type SetOutputActionFn<T extends Action> = (
   key: keyof T["outputs"],
   value: T["outputs"][typeof key]["value"],
 ) => void;
-export type SetOutputLoopFn<T extends Loop> = (
-  key: keyof T["outputs"],
-  value: T["outputs"][typeof key]["value"],
-) => void;
+
 export type SetOutputExpressionFn<T extends Expression> = (
   key: keyof T["outputs"],
   value: T["outputs"][typeof key]["value"],
@@ -244,12 +261,6 @@ export type ExtractInputsFromAction<ACTION extends Action> = {
   [index in keyof ACTION["params"]]: ACTION["params"][index]["value"];
 };
 
-export type ExtractInputsFromCondition<CONDITION extends Condition> = {
-  [index in keyof CONDITION["params"]]: CONDITION["params"][index]["value"];
-};
-export type ExtractInputsFromLoop<LOOP extends Loop> = {
-  [index in keyof LOOP["params"]]: LOOP["params"][index]["value"];
-};
 export type ExtractInputsFromEvent<EVENT extends Event> = {
   [index in keyof EVENT["params"]]: EVENT["params"][index]["value"];
 };
@@ -257,32 +268,6 @@ export type ExtractInputsFromExpression<EXPRESSION extends Expression> = {
   [index in keyof EXPRESSION["params"]]: EXPRESSION["params"][index]["value"];
 };
 
-export interface Condition extends BaseNode {
-  id: string;
-  type: "condition";
-  version?: number;
-  displayString: string;
-  icon: string;
-  name: string;
-  description: string;
-  params: InputsDefinition;
-  meta?: Meta;
-  platforms?: NodeJS.Platform[];
-}
-
-export interface Loop extends BaseNode {
-  id: string;
-  type: "loop";
-  version?: number;
-  displayString: string;
-  icon: string;
-  name: string;
-  description: string;
-  params: InputsDefinition;
-  meta?: Meta;
-  outputs: OutputsDefinition;
-}
-
 export interface Expression extends BaseNode {
   id: string;
   type: "expression";
@@ -309,7 +294,7 @@ export interface Event extends BaseNode {
   platforms?: NodeJS.Platform[];
 }
 
-export type PipelabNode = Event | Condition | Expression | Action | Loop;
+export type PipelabNode = Event | Expression | Action;
 
 export const createDefinition = <T extends MainPluginDefinition>(definition: T) => {
   return definition satisfies T;
@@ -450,20 +435,6 @@ export const createExpression = <T extends Omit<Expression, "type">>(expression:
   } satisfies Expression;
 };
 
-export const createCondition = <T extends Omit<Condition, "type">>(condition: T) => {
-  return {
-    ...condition,
-    type: "condition",
-  } satisfies Condition;
-};
-
-export const createLoop = <T extends Omit<Loop, "type">>(loop: T) => {
-  return {
-    ...loop,
-    type: "loop",
-  } satisfies Loop;
-};
-
 export const createEvent = <T extends Omit<Event, "type">>(event: T) => {
   return {
     ...event,

package/src/plugins-list.ts

@@ -0,0 +1,17 @@
+export const DEFAULT_PLUGIN_IDS = [
+  "construct",
+  "filesystem",
+  "system",
+  "steam",
+  "itch",
+  "electron",
+  "discord",
+  "poki",
+  "nvpatch",
+  "netlify",
+];
+
+export const DEV_ONLY_PLUGIN_IDS = [
+  "tauri",
+  "minify",
+];

package/src/plugins.ts

@@ -9,7 +9,16 @@ export const usePlugins = () => {
   const load = () => {};
 
   const registerPlugins = (newPlugins: Plugin[]) => {
-    plugins.value.push(...newPlugins);
+    const current = [...plugins.value];
+    for (const np of newPlugins) {
+      const idx = current.findIndex((p) => p.id === np.id);
+      if (idx !== -1) {
+        current[idx] = np;
+      } else {
+        current.push(np);
+      }
+    }
+    plugins.value = current;
   };
 
   return {

package/src/utils.ts

@@ -1,3 +1,29 @@
 export const foo = "bar";
 
 export type WithId<T> = T extends string | number ? never : T & { id: string };
+
+export const transformUrl = (url: string | undefined | null): string => {
+  if (url && typeof url === "string") {
+    const getHost = (): string => {
+      if (typeof window !== "undefined") {
+        const isDev = process.env.NODE_ENV === "development";
+        if (isDev) {
+          return `http://${window.location.hostname}:33753`;
+        } else {
+          return `${window.location.protocol}//${window.location.host}`;
+        }
+      }
+      return "http://localhost:33753";
+    };
+
+    if (url.startsWith("file://")) {
+      const filePath = decodeURIComponent(url.substring("file://".length));
+      return `${getHost()}/media-file/${encodeURIComponent(filePath)}`;
+    }
+    if (url.startsWith("media://")) {
+      const filePath = decodeURIComponent(url.replace(/^media:\/\/+/, "/"));
+      return `${getHost()}/media-file/${encodeURIComponent(filePath)}`;
+    }
+  }
+  return url || "";
+};

package/tsconfig.json

@@ -3,11 +3,9 @@
   "compilerOptions": {
     "emitDeclarationOnly": true,
     "outDir": "dist",
-    "baseUrl": ".",
-    "typeRoots": ["./src"],
-    "types": ["global.d.ts", "wasm.d.ts"]
+    "baseUrl": "."
   },
-  "include": ["src/**/*", "tests/**/*", "*.ts", "src/**/*.json"],
+  "include": ["src/**/*", "src/**/*.json"],
   "exclude": ["node_modules", "dist"],
   "references": [{ "path": "../migration" }]
 }

package/tsconfig.test.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": false,
+    "noEmit": true
+  },
+  "include": ["src/**/*", "tests/**/*", "*.ts"]
+}