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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/core-node",
-  "version": "1.0.0-beta.18",
+  "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.16",
-    "@pipelab/shared": "1.0.0-beta.14"
+    "@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.14"
+    "@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";
@@ -39,7 +44,7 @@ describe("setupConfigFile & Backup Creation", () => {
     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",
@@ -56,7 +61,7 @@ describe("setupConfigFile & Backup Creation", () => {
     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);
@@ -82,12 +87,12 @@ 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);
@@ -100,11 +105,11 @@ 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("3.0.0");
@@ -124,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,
@@ -135,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,
     });
@@ -156,7 +161,7 @@ describe("setupConfigFile & Backup Creation", () => {
   });
 
   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 = {
@@ -176,9 +181,52 @@ describe("setupConfigFile & Backup Creation", () => {
     expect(success).toBe(true);
 
     const savedContent = JSON.parse(
-      await fs.readFile(path.join(context.getConfigPath(), "projects.json"), "utf8"),
+      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 } 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,14 +59,13 @@ 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 = ctx.getConfigPath(`${parsedPath.name}.v${version}.json`);
+              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}:`,
+                  `Failed to create intermediate backup for ${parsedPath.name} at v${version}:`,
                   e,
                 );
               }
@@ -78,7 +75,7 @@ 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;
       }
@@ -92,9 +89,9 @@ export const setupConfigFile = async <T>(
       if (shouldSaveBack) {
         if (parseFailed || migrationFailed) {
           try {
-            const parsedPath = path.parse(filesPath);
             const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-            const corruptedPath = ctx.getConfigPath(
+            const corruptedPath = path.join(
+              parsedPath.dir,
               `${parsedPath.name}.corrupted.${timestamp}.json`,
             );
             const backupContent = parseFailed
@@ -103,14 +100,14 @@ export const setupConfigFile = async <T>(
             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);
         }
       }
 
@@ -119,9 +116,51 @@ export const setupConfigFile = async <T>(
   };
 };
 
-export const deleteConfigFile = async (nameOrPath: string, context: PipelabContext) => {
-  const isAbsolutePath = path.isAbsolute(nameOrPath);
-  const filesPath = isAbsolutePath ? nameOrPath : context.getConfigPath(`${nameOrPath}.json`);
+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";
 
@@ -85,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-") {
@@ -99,10 +135,12 @@ export class PipelabContext {
   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 join(this.userDataPath, "cache");
+      return base;
     }
-    return join(this.userDataPath, "cache", folder, ...subpaths);
+    return join(base, folder, ...subpaths);
   }
 
   getPnpmPath(...subpaths: string[]) {