@pipelab/shared 1.0.0-beta.6 → 1.0.0-beta.8

package/src/model.test.ts

@@ -1,5 +1,11 @@
 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,
+} from "./config/migrators";
+import { AppConfigV6, AppConfigV8 } from "./config.schema";
 
 describe("model", () => {
   it("should migrate 1.0.0 to 2.0.0", async () => {
@@ -211,4 +217,173 @@ 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 AppConfigV8", 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 v8 = await appSettingsMigrator.migrate(v6, { target: "8.0.0" });
+
+    expect(v8).toStrictEqual({
+      version: "8.0.0",
+      theme: "dark",
+      locale: "fr-FR",
+      tours: {
+        dashboard: { step: 1, completed: true },
+        editor: { step: 2, completed: false },
+      },
+      autosave: false,
+      agents: [],
+      buildHistory: {
+        retentionPolicy: {
+          enabled: false,
+          maxEntries: 50,
+          maxAge: 30,
+        },
+      },
+      plugins: expect.any(Array),
+      isInternalMigrationBannerClosed: false,
+    });
+  });
+
+  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");
+    });
+  });
 });

package/src/model.ts

@@ -32,6 +32,10 @@ export type Position = {
 export const OriginValidator = object({
   pluginId: string(),
   nodeId: string(),
+  version: pipe(
+    optional(string()),
+    description('Pinned version of the plugin for this block. Falls back to "latest" when absent.'),
+  ),
 });
 
 export type Origin = InferOutput<typeof OriginValidator>;
@@ -61,39 +65,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 +151,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 +181,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 +237,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

@@ -154,10 +154,8 @@ export type IconType =
       icon: string;
     };
 export interface PluginDefinition {
-  id: string;
-  name: string;
-  icon: IconType;
-  description: string;
+  packageName?: string;
+  version?: string;
 }
 
 export type RendererNodeDefinition = {
@@ -165,6 +163,13 @@ export type RendererNodeDefinition = {
 };
 
 export interface RendererPluginDefinition extends PluginDefinition {
+  id: string;
+  name: string;
+  icon: IconType;
+  description: string;
+  isOfficial: boolean;
+  packageName: string;
+  version: string;
   nodes: Array<RendererNodeDefinition>;
 }
 
@@ -203,10 +208,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 +246,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 +253,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 +279,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 +420,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.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 = window.location.port === "5173";
+        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 = url.substring("file://".length);
+      return `${getHost()}/media-file/${encodeURIComponent(filePath)}`;
+    }
+    if (url.startsWith("media://")) {
+      const filePath = url.replace(/^media:\/\/+/, "/");
+      return `${getHost()}/media-file/${encodeURIComponent(filePath)}`;
+    }
+  }
+  return url || "";
+};