@pipelab/core-node 1.0.0-beta.17 → 1.0.0-beta.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/core-node",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.19",
   "private": false,
   "description": "The Pipelab automation engine for Node.js",
   "license": "FSL-1.1-MIT",
@@ -40,8 +40,8 @@
     "type-fest": "4.39.0",
     "ws": "8.18.3",
     "yauzl": "2.10.0",
-    "@pipelab/constants": "1.0.0-beta.15",
-    "@pipelab/shared": "1.0.0-beta.13"
+    "@pipelab/constants": "1.0.0-beta.17",
+    "@pipelab/shared": "1.0.0-beta.15"
   },
   "devDependencies": {
     "@types/adm-zip": "0.5.7",
@@ -56,7 +56,7 @@
     "tsdown": "0.21.2",
     "typescript": "^5.0.0",
     "vitest": "3.1.4",
-    "@pipelab/tsconfig": "1.0.0-beta.13"
+    "@pipelab/tsconfig": "1.0.0-beta.15"
   },
   "scripts": {
     "build": "tsdown",

package/src/config.test.ts

@@ -1,5 +1,10 @@
 import { describe, test, expect, beforeEach, vi } from "vitest";
-import { setupConfigFile } from "./config";
+import {
+  setupConfigFile,
+  setupProjectsConfigFile,
+  deletePipelineConfigFileByName,
+  deletePipelineConfigFileByPath,
+} from "./config";
 import { FileRepo } from "@pipelab/shared";
 import { PipelabContext } from "./context";
 import fs from "node:fs/promises";
@@ -38,9 +43,9 @@ describe("setupConfigFile & Backup Creation", () => {
     // 1. Setup V1 configuration file in the context's config path
     const configDir = context.getConfigPath();
     await fs.mkdir(configDir, { recursive: true });
-    
-    const projectsFilePath = path.join(configDir, "projects.json");
-    
+
+    const projectsFilePath = context.getProjectsPath();
+
     const v1Config = {
       version: "1.0.0",
       data: {
@@ -49,14 +54,14 @@ describe("setupConfigFile & Backup Creation", () => {
           type: "internal",
           configName: "pipeline-1",
           lastModified: "2026-06-04",
-        }
-      }
+        },
+      },
     };
-    
+
     await fs.writeFile(projectsFilePath, JSON.stringify(v1Config));
 
     // 2. Initialize setupConfigFile
-    const configInstance = await setupConfigFile<FileRepo>("projects", { context });
+    const configInstance = await setupProjectsConfigFile(context);
 
     // Verify file exists
     expect(existsSync(projectsFilePath)).toBe(true);
@@ -64,11 +69,11 @@ describe("setupConfigFile & Backup Creation", () => {
     // 3. Retrieve config (this triggers the migration process and onStep callback)
     const migratedConfig = await configInstance.getConfig();
 
-    // 4. Assert the main config is updated on disk to version 2.0.0
-    expect(migratedConfig.version).toBe("2.0.0");
-    
+    // 4. Assert the main config is updated on disk to version 3.0.0
+    expect(migratedConfig.version).toBe("3.0.0");
+
     const updatedContent = JSON.parse(await fs.readFile(projectsFilePath, "utf8"));
-    expect(updatedContent.version).toBe("2.0.0");
+    expect(updatedContent.version).toBe("3.0.0");
 
     // 5. Assert that the intermediate backup file was created on disk
     const backupFilePath = path.join(configDir, "projects.v2.0.0.json");
@@ -82,17 +87,17 @@ describe("setupConfigFile & Backup Creation", () => {
 
   test("should create default config file if missing on setup", async () => {
     const configDir = context.getConfigPath();
-    const projectsFilePath = path.join(configDir, "projects.json");
+    const projectsFilePath = context.getProjectsPath();
 
     expect(existsSync(projectsFilePath)).toBe(false);
 
     // Initialize setupConfigFile
-    await setupConfigFile<FileRepo>("projects", { context });
+    await setupProjectsConfigFile(context);
 
     // Should create file with default value
     expect(existsSync(projectsFilePath)).toBe(true);
     const content = JSON.parse(await fs.readFile(projectsFilePath, "utf8"));
-    expect(content.version).toBe("2.0.0");
+    expect(content.version).toBe("3.0.0");
     expect(content.projects).toHaveLength(1);
     expect(content.pipelines).toEqual([]);
   });
@@ -100,20 +105,22 @@ describe("setupConfigFile & Backup Creation", () => {
   test("should fallback to default config and preserve corrupted file if parsing fails", async () => {
     const configDir = context.getConfigPath();
     await fs.mkdir(configDir, { recursive: true });
-    const projectsFilePath = path.join(configDir, "projects.json");
+    const projectsFilePath = context.getProjectsPath();
 
     await fs.writeFile(projectsFilePath, "{ corrupted json... }");
 
-    const configInstance = await setupConfigFile<FileRepo>("projects", { context });
+    const configInstance = await setupProjectsConfigFile(context);
     const config = await configInstance.getConfig();
 
-    expect(config.version).toBe("2.0.0");
+    expect(config.version).toBe("3.0.0");
     expect(config.projects).toHaveLength(1);
     expect(config.pipelines).toEqual([]);
 
     // Verify a timestamped corrupted backup file exists
     const files = await fs.readdir(configDir);
-    const corruptedFile = files.find(f => f.startsWith("projects.corrupted.") && f.endsWith(".json"));
+    const corruptedFile = files.find(
+      (f) => f.startsWith("projects.corrupted.") && f.endsWith(".json"),
+    );
     expect(corruptedFile).toBeDefined();
     const corruptedContent = await fs.readFile(path.join(configDir, corruptedFile!), "utf8");
     expect(corruptedContent).toBe("{ corrupted json... }");
@@ -122,7 +129,7 @@ describe("setupConfigFile & Backup Creation", () => {
   test("should fallback to default config and preserve file if migration throws", async () => {
     const configDir = context.getConfigPath();
     await fs.mkdir(configDir, { recursive: true });
-    const projectsFilePath = path.join(configDir, "projects.json");
+    const projectsFilePath = context.getProjectsPath();
 
     const customMigrator = {
       defaultValue: { version: "2.0.0", projects: [], pipelines: [] } as any,
@@ -133,7 +140,7 @@ describe("setupConfigFile & Backup Creation", () => {
 
     await fs.writeFile(projectsFilePath, JSON.stringify({ version: "1.0.0", invalidData: true }));
 
-    const configInstance = await setupConfigFile<any>("projects", {
+    const configInstance = await setupConfigFile<any>(context.getProjectsPath(), {
       context,
       migrator: customMigrator,
     });
@@ -143,14 +150,18 @@ describe("setupConfigFile & Backup Creation", () => {
 
     // Verify a timestamped corrupted backup file exists
     const files = await fs.readdir(configDir);
-    const corruptedFile = files.find(f => f.startsWith("projects.corrupted.") && f.endsWith(".json"));
+    const corruptedFile = files.find(
+      (f) => f.startsWith("projects.corrupted.") && f.endsWith(".json"),
+    );
     expect(corruptedFile).toBeDefined();
-    const corruptedContent = JSON.parse(await fs.readFile(path.join(configDir, corruptedFile!), "utf8"));
+    const corruptedContent = JSON.parse(
+      await fs.readFile(path.join(configDir, corruptedFile!), "utf8"),
+    );
     expect(corruptedContent.invalidData).toBe(true);
   });
 
   test("should save config to disk via setConfig", async () => {
-    const configInstance = await setupConfigFile<FileRepo>("projects", { context });
+    const configInstance = await setupProjectsConfigFile(context);
     const initialConfig = await configInstance.getConfig();
 
     const newConfig: FileRepo = {
@@ -169,8 +180,53 @@ describe("setupConfigFile & Backup Creation", () => {
     const success = await configInstance.setConfig(newConfig);
     expect(success).toBe(true);
 
-    const savedContent = JSON.parse(await fs.readFile(path.join(context.getConfigPath(), "projects.json"), "utf8"));
+    const savedContent = JSON.parse(
+      await fs.readFile(context.getProjectsPath(), "utf8"),
+    );
     expect(savedContent.pipelines).toHaveLength(1);
     expect(savedContent.pipelines[0].id).toBe("pipeline-new");
   });
 });
+
+describe("deletePipelineConfigFile", () => {
+  let tempDir: string;
+  let context: PipelabContext;
+
+  beforeEach(() => {
+    vol.reset();
+    tempDir = "/tmp/pipelab-test-config";
+    context = new PipelabContext({ userDataPath: tempDir });
+  });
+
+  test("should delete pipeline config file using relative name", async () => {
+    const configDir = context.getConfigPath();
+    await fs.mkdir(configDir, { recursive: true });
+
+    const pipelineFilePath = path.join(configDir, "my-pipeline.json");
+    await fs.writeFile(pipelineFilePath, JSON.stringify({ name: "My Pipeline" }));
+    expect(existsSync(pipelineFilePath)).toBe(true);
+
+    await deletePipelineConfigFileByName("my-pipeline", context);
+    expect(existsSync(pipelineFilePath)).toBe(false);
+  });
+
+  test("should delete pipeline config file using absolute path", async () => {
+    const configDir = context.getConfigPath();
+    await fs.mkdir(configDir, { recursive: true });
+
+    const pipelineFilePath = path.join(configDir, "another-pipeline.json");
+    await fs.writeFile(pipelineFilePath, JSON.stringify({ name: "Another Pipeline" }));
+    expect(existsSync(pipelineFilePath)).toBe(true);
+
+    await deletePipelineConfigFileByPath(pipelineFilePath, context);
+    expect(existsSync(pipelineFilePath)).toBe(false);
+  });
+
+  test("should not throw error when attempting to delete non-existent pipeline file", async () => {
+    const nonExistentPath = context.getConfigPath("does-not-exist.json");
+    expect(existsSync(nonExistentPath)).toBe(false);
+
+    await expect(deletePipelineConfigFileByName("does-not-exist", context)).resolves.not.toThrow();
+  });
+});
+

package/src/config.ts

@@ -2,28 +2,26 @@ import { PipelabContext } from "./context";
 import path from "node:path";
 import { ensure } from "./utils/fs-extras";
 import fs from "node:fs/promises";
-import { useLogger } from "@pipelab/shared";
-import { configRegistry, Migrator, normalizePipelineConfig } from "@pipelab/shared";
-
-export const getMigrator = <T>(name: string) => {
-  return (configRegistry[name] || configRegistry["pipeline"]) as Migrator<T>;
-};
+import {
+  useLogger,
+  Migrator,
+  AppConfig,
+  ConnectionsConfig,
+  FileRepo,
+  SavedFile,
+  appSettingsMigrator,
+  connectionsMigrator,
+  fileRepoMigrations,
+  savedFileMigrator,
+} from "@pipelab/shared";
 
 export const setupConfigFile = async <T>(
-  name: string,
-  options: { context: PipelabContext; migrator?: Migrator<T> },
+  filesPath: string,
+  options: { context: PipelabContext; migrator: Migrator<T> },
 ) => {
   const ctx = options.context;
-  const migrator = options.migrator || getMigrator<T>(name);
-
-  if (!migrator) {
-    throw new Error(
-      `No migrator found for configuration: ${name}. All managed files must have a migration schema.`,
-    );
-  }
-
-  const isAbsolutePath = path.isAbsolute(name);
-  const filesPath = isAbsolutePath ? name : ctx.getConfigPath(`${name}.json`);
+  const parsedPath = path.parse(filesPath);
+  const migrator = options.migrator;
 
   await ensure(filesPath, JSON.stringify(migrator.defaultValue));
 
@@ -34,7 +32,7 @@ export const setupConfigFile = async <T>(
         await fs.writeFile(filesPath, JSON.stringify(config));
         return true;
       } catch (e) {
-        logger().error(`Error saving config ${name}:`, e);
+        logger().error(`Error saving config ${parsedPath.name}:`, e);
         return false;
       }
     },
@@ -50,7 +48,7 @@ export const setupConfigFile = async <T>(
           originalJson = JSON.parse(content);
         }
       } catch (e) {
-        logger().error(`Error reading or parsing config ${name}:`, e);
+        logger().error(`Error reading or parsing config ${parsedPath.name}:`, e);
         parseFailed = true;
       }
 
@@ -61,13 +59,15 @@ export const setupConfigFile = async <T>(
           json = await migrator.migrate(originalJson, {
             debug: false,
             onStep: async (state: any, version: string) => {
-              const parsedPath = path.parse(filesPath);
               const versionedPath = path.join(parsedPath.dir, `${parsedPath.name}.v${version}.json`);
               try {
                 await fs.writeFile(versionedPath, JSON.stringify(state));
-                logger().info(`Intermediate backup created for ${name} at ${versionedPath}`);
+                logger().info(`Intermediate backup created for ${parsedPath.name} at ${versionedPath}`);
               } catch (e) {
-                logger().error(`Failed to create intermediate backup for ${name} at v${version}:`, e);
+                logger().error(
+                  `Failed to create intermediate backup for ${parsedPath.name} at v${version}:`,
+                  e,
+                );
               }
             },
           });
@@ -75,52 +75,39 @@ export const setupConfigFile = async <T>(
           json = migrator.defaultValue;
         }
       } catch (e) {
-        logger().error(`Error migrating config ${name}:`, e);
+        logger().error(`Error migrating config ${parsedPath.name}:`, e);
         migrationFailed = true;
         json = migrator.defaultValue;
       }
 
-      let normalized = false;
-      const isPipeline =
-        name.startsWith("pipeline-") ||
-        path.isAbsolute(name) ||
-        name.endsWith(".json") ||
-        name === "pipeline";
-      if (isPipeline) {
-        normalized = normalizePipelineConfig(json);
-      }
-
       const originalVersion = originalJson?.version;
       const newVersion = json?.version;
 
       const shouldSaveBack =
-        originalVersion !== newVersion ||
-        normalized ||
-        content === undefined ||
-        parseFailed ||
-        migrationFailed;
+        originalVersion !== newVersion || content === undefined || parseFailed || migrationFailed;
 
       if (shouldSaveBack) {
         if (parseFailed || migrationFailed) {
           try {
-            const parsedPath = path.parse(filesPath);
             const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
             const corruptedPath = path.join(
               parsedPath.dir,
               `${parsedPath.name}.corrupted.${timestamp}.json`,
             );
-            const backupContent = parseFailed ? (content || "") : JSON.stringify(originalJson, null, 2);
+            const backupContent = parseFailed
+              ? content || ""
+              : JSON.stringify(originalJson, null, 2);
             await fs.writeFile(corruptedPath, backupContent);
             logger().info(`Corrupted config file preserved at ${corruptedPath}`);
           } catch (e) {
-            logger().error(`Failed to backup corrupted config ${name}:`, e);
+            logger().error(`Failed to backup corrupted config ${parsedPath.name}:`, e);
           }
         }
 
         try {
           await fs.writeFile(filesPath, JSON.stringify(json));
         } catch (e) {
-          logger().error(`Error saving migrated config ${name}:`, e);
+          logger().error(`Error saving migrated config ${parsedPath.name}:`, e);
         }
       }
 
@@ -128,3 +115,52 @@ export const setupConfigFile = async <T>(
     },
   };
 };
+
+export const setupSettingsConfigFile = (context: PipelabContext) => {
+  return setupConfigFile<AppConfig>(context.getSettingsPath(), {
+    context,
+    migrator: appSettingsMigrator,
+  });
+};
+
+export const setupConnectionsConfigFile = (context: PipelabContext) => {
+  return setupConfigFile<ConnectionsConfig>(context.getConnectionsPath(), {
+    context,
+    migrator: connectionsMigrator,
+  });
+};
+
+export const setupProjectsConfigFile = (context: PipelabContext) => {
+  return setupConfigFile<FileRepo>(context.getProjectsPath(), {
+    context,
+    migrator: fileRepoMigrations,
+  });
+};
+
+export const setupPipelineConfigFileByName = (name: string, context: PipelabContext) => {
+  const filesPath = context.getConfigPath(`${name}.json`);
+  return setupConfigFile<SavedFile>(filesPath, {
+    context,
+    migrator: savedFileMigrator,
+  });
+};
+
+export const setupPipelineConfigFileByPath = (absolutePath: string, context: PipelabContext) => {
+  return setupConfigFile<SavedFile>(absolutePath, {
+    context,
+    migrator: savedFileMigrator,
+  });
+};
+
+const deleteConfigFile = async (filesPath: string) => {
+  await fs.rm(filesPath, { force: true });
+};
+
+export const deletePipelineConfigFileByName = async (name: string, context: PipelabContext) => {
+  const filesPath = context.getConfigPath(`${name}.json`);
+  await deleteConfigFile(filesPath);
+};
+
+export const deletePipelineConfigFileByPath = async (absolutePath: string, context: PipelabContext) => {
+  await deleteConfigFile(absolutePath);
+};

package/src/context.ts

@@ -1,7 +1,7 @@
 import { join, dirname, resolve } from "node:path";
 import { homedir, platform } from "node:os";
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, realpath, mkdtemp } from "node:fs/promises";
 import { SandboxFolder, DEFAULT_NODE_VERSION, DEFAULT_PNPM_VERSION } from "@pipelab/constants";
 
@@ -51,6 +51,14 @@ function findProjectRoot(startDir: string): string | null {
 
 export const projectRoot = findProjectRoot(_dirname);
 
+export const CacheFolder = {
+  Actions: "actions",
+  Pipelines: "pipelines",
+  Pacote: "pacote",
+} as const;
+
+export type CacheFolderType = (typeof CacheFolder)[keyof typeof CacheFolder];
+
 export interface PipelabContextOptions {
   userDataPath: string;
   releaseTag?: string;
@@ -77,8 +85,44 @@ export class PipelabContext {
     return join(this.userDataPath, "config", ...subpaths);
   }
 
+  getSettingsPath() {
+    return this.getConfigPath("settings.json");
+  }
+
+  getConnectionsPath() {
+    return this.getConfigPath("connections.json");
+  }
+
+  getProjectsPath() {
+    return this.getConfigPath("projects.json");
+  }
+
+  private _cachedSettings: any = null;
+  private _cachedSettingsTime: number = 0;
+
+  private getSettings() {
+    const settingsPath = this.getSettingsPath();
+    if (!existsSync(settingsPath)) {
+      return null;
+    }
+    const now = Date.now();
+    if (this._cachedSettings && now - this._cachedSettingsTime < 2000) {
+      return this._cachedSettings;
+    }
+    try {
+      const content = readFileSync(settingsPath, "utf8");
+      this._cachedSettings = JSON.parse(content);
+      this._cachedSettingsTime = now;
+      return this._cachedSettings;
+    } catch (e) {
+      return this._cachedSettings;
+    }
+  }
+
   getTempPath(...subpaths: string[]) {
-    return join(this.userDataPath, "temp", ...subpaths);
+    const settings = this.getSettings();
+    const base = settings?.tempFolder || join(this.userDataPath, "temp");
+    return join(base, ...subpaths);
   }
 
   async createTempFolder(prefix = "pipelab-") {
@@ -88,14 +132,25 @@ export class PipelabContext {
     return await mkdtemp(join(realBaseDir, prefix));
   }
 
-  getCachePath(...subpaths: string[]) {
-    return join(this.userDataPath, "cache", ...subpaths);
+  getCachePath(): string;
+  getCachePath(folder: CacheFolderType, ...subpaths: string[]): string;
+  getCachePath(folder?: CacheFolderType, ...subpaths: string[]) {
+    const settings = this.getSettings();
+    const base = settings?.cacheFolder || join(this.userDataPath, "cache");
+    if (!folder) {
+      return base;
+    }
+    return join(base, folder, ...subpaths);
   }
 
   getPnpmPath(...subpaths: string[]) {
     return join(this.userDataPath, "pnpm", ...subpaths);
   }
 
+  getBuildHistoryPath(...subpaths: string[]) {
+    return join(this.userDataPath, "build-history", ...subpaths);
+  }
+
   getNodePath(version = DEFAULT_NODE_VERSION) {
     const isWindows = process.platform === "win32";
     return this.getThirdPartyPath("node", version, isWindows ? "node.exe" : "bin/node");