lucy-cli 2.0.0-alpha.9 → 2.0.0-beta.1

package/src/commands/checks.ts

@@ -0,0 +1,51 @@
+import { Effect, Schema } from "effect/index";
+import { FileSystem, Path } from "@effect/platform"
+import { Config, lucyJsonName } from "../config.js";
+import { logger } from "../utils/logger.js";
+import { AppError } from "../error.js";
+import { JsonSchema } from "../schemas/index.js";
+
+export const isDirectoryClean =(excludes: string[] = []) => {
+    return Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem;
+        const config = yield* Config;
+
+        const files = yield* fs.readDirectory(config.config.cwd);
+        const allExcludes = [...excludes, '.git', lucyJsonName];
+        const filteredFiles = files.filter(file => !allExcludes.includes(file));
+
+        return filteredFiles.length > 0 ? false : true;
+    });
+}
+
+export const checkForDirty = (excludes: string[] = []) => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const clean = yield* isDirectoryClean(excludes);
+        if(!clean && !config.config.force) {
+            logger.alert("The current directory is not empty. Please run this command in an empty directory.")
+            yield* Effect.fail(new AppError({ message: "Directory is not clean", cause: new Error("Directory is not clean") }));
+            return;
+        }
+        if(config.config.lucySettings.initialized && !config.config.force) {
+            logger.alert("Lucy is already initialized in this directory. Use --force to reinitialize.")
+            yield* Effect.fail(new AppError({ message: "Lucy is already initialized in this directory", cause: new Error("Lucy is already initialized in this directory") }));
+            return;
+        }
+
+        if ((!clean && config.config.force) || (config.config.lucySettings.initialized && config.config.force)) logger.alert("Forced initialization!")
+    });
+}
+export const checkForVelo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+
+        const wixConfigPath = path.join(config.config.cwd, 'wix.config.json'); 
+        const wixConfigRaw = yield* fs.readFileString(wixConfigPath);
+        const wixConfigJSON =( yield* Schema.decodeUnknown(JsonSchema)(wixConfigRaw)) as any;
+
+        if(!(wixConfigJSON.siteId)) return yield* Effect.fail(new AppError({ message: "This directory is not a Velo project. Please run this command in a Velo project directory.", cause: new Error("Not a Velo project") }));
+    });
+}

package/src/commands/cleanup.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect/index";
+import { Config } from "../config.js";
+import { FileSystem, Path } from "@effect/platform"
+
+export const cleanup = Effect.gen(function* () {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+
+    yield* fs.remove(path.join(config.config.cwd, "package-lock.json"), { force: true })
+});

package/src/commands/copy.ts

@@ -0,0 +1,28 @@
+import { Effect } from "effect/index";
+import { Path } from "@effect/platform"
+import { FileSystem } from "@effect/platform"
+import { Config, syncDataName, syncFilesSource } from "../config.js";
+
+export const copyTemplateFiles = Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const config = yield* Config;
+    const path = yield * Path.Path;
+
+    const templateFiles = yield* fs.readDirectory(config.config.templateFiles)
+    yield* Effect.forEach(
+        templateFiles,
+        (file) => fs.copy(path.join(config.config.templateFiles, file), path.join(config.config.cwd, file), { overwrite: true })
+    )
+})
+export const copySyncFiles = Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const config = yield* Config;
+    const path = yield * Path.Path;
+
+    const synDataFiles = yield* fs.readDirectory(syncFilesSource)
+    yield* fs.makeDirectory(path.join(config.config.cwd, syncDataName));
+    yield* Effect.forEach(
+        synDataFiles,
+        (file) => fs.copy(path.join(syncFilesSource, file), path.join(config.config.cwd, syncDataName, file), { overwrite: true })
+    )
+})

package/src/commands/edit.ts

@@ -0,0 +1,81 @@
+import { Effect, Schema } from "effect/index";
+import { Config, lucyJsonPath } from "../config.js";
+import { FileSystem, Path } from "@effect/platform"
+import { logger } from "../utils/logger.js";
+import { JsonSchema } from "../schemas/index.js";
+import { LucySettings } from "../schemas/lucy.js";
+
+export const editJson = (json: any, keys: string[], values: string[] | Object[]) => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+
+        for (const key of keys){
+			const index = keys.indexOf(key);
+			const value = values[index];
+			json[key] = value;
+		}
+    })
+}
+
+export const mergeLucySettings2PackageJson = Effect.gen(function*() {
+    const config = yield* Config;
+    const lucySettings = config.config.lucySettings;
+    const packageJson = config.config.packageJson;
+
+    if (Object.keys(lucySettings.scripts).length > 0) {
+        yield* editJson(packageJson, ['scripts'], [{...packageJson.scripts, ...lucySettings.scripts}]);
+    }
+})
+
+export const setModule = Effect.gen(function*() {
+    const config = yield* Config;
+    const lucySettings = config.config.lucySettings;
+    const packageJson = config.config.packageJson;
+
+	yield* editJson(packageJson, ['type'], ['module']);
+})
+
+export const mergeAdditions = Effect.gen(function*() {
+    const config = yield* Config;
+    const lucySettings = config.config.lucySettings;
+    const packageJson = config.config.packageJson;
+
+	config.config.packageJson = {
+        ...packageJson,
+        ...lucySettings.additionalPkgProps,
+    }
+})
+
+export const setProjectName = Effect.gen(function*() {
+    const config = yield* Config;
+    const packageJson = config.config.packageJson;
+
+	yield * editJson(packageJson, ["name"], [config.config.projectName]);
+})
+
+export const setInitialized = Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const lucyRaw = yield* fs.readFileString(lucyJsonPath);
+    const lucyJSON = (yield* Schema.decodeUnknown(JsonSchema)(lucyRaw)) as any;
+    lucyJSON.initialized = true;
+
+    yield* fs.writeFileString(lucyJsonPath, JSON.stringify(lucyJSON, null, 2));
+})
+
+export const stringReplace = (filePath: string, keys: string[], values: string[]) => {
+    return Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem;
+        let modifiedContent: string = '';
+
+        logger.action(`Replacing ${keys} with ${values} in ${filePath}`);
+        const data = yield* fs.readFileString(filePath, 'utf8');
+        for (const key of keys){
+			const index = keys.indexOf(key);
+			const value = values[index];
+			const regex = new RegExp(`${key}`, 'g');
+			modifiedContent = data.replace(regex, `${value}`);
+		}
+        yield* fs.writeFileString(filePath, modifiedContent);
+        logger.info(`Updated file ${filePath}`);
+    })
+}

package/src/commands/exec.ts

@@ -0,0 +1,69 @@
+import { Effect, Schema } from "effect/index";
+import { Config } from "../config.js";
+import { Command } from "@effect/platform/index";
+import { logger } from "../utils/logger.js";
+import { FileSystem } from "@effect/platform"
+import Enquirer from "enquirer";
+import { AppError } from "../error.js";
+
+export const execCommand = Effect.gen(function*() {
+    const config = yield* Config;
+    const cmds = config.config.lucySettings.additionalCommands ?? [];
+    logger.info("Executing additional commands...", cmds);
+    if (cmds.length > 0) {
+        logger.info("Executing additional commands");
+      yield *
+        Effect.all([
+            ...cmds.map((cmd) => {
+            return Command.make(cmd[0], ...cmd.slice(1))
+                .pipe()
+                .pipe(Command.stdout("inherit"), Command.stderr("inherit"), Command.exitCode);
+            }),
+        ]);
+    }
+})
+
+export const open = Effect.scoped(Effect.gen(function*() {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem
+    console.log("Opening Lucy home directory:", config.config.lucyHome);
+    let command: ReturnType<typeof Command.make>;
+    switch (process.platform) {
+        case 'darwin': command = Command.make('open', config.config.lucyHome); break;
+        case 'win32': command = Command.make('start', config.config.lucyHome); break;
+        default: command = Command.make('xdg-open', config.config.lucyHome); break;
+    }
+
+    command.pipe().pipe(Command.stdout("inherit"), Command.stderr("inherit"), Command.exitCode);
+    yield* command.pipe().pipe(Command.stdout("inherit"), Command.stderr("inherit"), Command.exitCode);
+}))
+
+export const openVSCode = Effect.gen(function*() {
+    const config = yield* Config;
+    const open = Command.make(
+        "code", 
+        config.config.cwd,
+        ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.stderr("inherit"), // Stream stderr to process.stderr
+        Command.exitCode // Get the exit code
+    )
+    const overwriteQuestion = new Enquirer();
+    const openVScodeQuestion = yield* Effect.tryPromise({
+        try: () => overwriteQuestion.prompt({
+            type: 'confirm',
+            name: 'openVSCode',
+            message: `Do you want to open the project in VSCode?`,
+        }),
+        catch: (e) => {
+            return new AppError({
+                cause: e,
+                message: "Error opening VSCode",
+            });
+        }
+    })
+    const choice = yield* Schema.decodeUnknown(Schema.Struct({ openVSCode: Schema.Boolean }))(openVScodeQuestion);
+    if (choice.openVSCode) {
+        yield* open
+    }
+})

package/src/commands/git.ts

@@ -0,0 +1,113 @@
+import { Effect } from 'effect/index';
+import { simpleGit, SimpleGit } from 'simple-git';
+import { Config } from '../config.js';
+import { AppError } from '../error.js';
+import { logger } from '../utils/logger.js';
+import { FileSystem, Path } from "@effect/platform"
+
+export const isSubmoduleRegistered = (git: SimpleGit, submoduleName: string) => Effect.gen(function* () {
+    const value = yield* Effect.tryPromise({
+        try: () => git.getConfig(`submodule.${submoduleName}.url`),
+        catch: (error) => {
+            return new AppError({
+                cause: error,
+                message: "Failed to get submodule url",
+            });
+        }
+    })
+    return !!value.value;
+})
+
+export const gitInit = (update: boolean = false) => Effect.gen(function* () {
+    const config = yield* Config;
+    const git = simpleGit({ baseDir: config.config.cwd });
+    const path = yield * Path.Path;
+
+    const isGit = yield* Effect.tryPromise({
+        try: () => git.checkIsRepo(),
+        catch: (error) => {
+            return new AppError({
+                cause: error,
+                message: "Failed to check if the directory is a git repository",
+            });
+        }
+    })
+
+    if(!isGit) {
+        yield* Effect.tryPromise({
+            try: () => git.init(),
+            catch: (error) => {
+                return new AppError({
+                    cause: error,
+                    message: "Failed to initialize git repository",
+                });
+            }
+        })
+    }
+
+    if (!config.config.lucySettings.modules) {
+        logger.alert('No submodules defined in settings, skipping.');
+		return;
+	}
+    yield* initSubmodules(update);
+})
+
+export const initSubmodules = (update: boolean = false) => Effect.gen(function* () {
+    const config = yield* Config;
+    const git = simpleGit({ baseDir: config.config.cwd });
+    const path = yield* Path.Path;
+    const fs = yield* FileSystem.FileSystem;
+    const gitmodulesPath = path.join(config.config.cwd, ".gitmodules");
+
+    for (const [name, repo] of Object.entries(config.config.lucySettings.modules)) {
+        logger.action(`Processing submodule ${name}`);
+		const clonePath = repo.path || path.join(config.config.lucySettings.defaultModulePath ?? '', name);
+
+        const isRegistered = yield* isSubmoduleRegistered(git, clonePath);
+        const isConfiguredInFile = (yield* fs.exists(gitmodulesPath)) && (yield* fs.readFileString(gitmodulesPath, 'utf-8')).includes(`[submodule "${clonePath}"]`);
+
+        if (!isConfiguredInFile || config.config.force) {
+            logger.action(`Adding/updating submodule ${name} at ${clonePath}...`);
+            // If git already has a config entry, we must use --force to repair it.
+            const submoduleArgs = () => {
+                if (update) {
+                    return ['add', '--force', repo.source, clonePath];
+                }
+                return ['add', ...(config.config.force || isRegistered ? ['--force'] : []), repo.source, clonePath];
+            }
+            // await git.subModule(submoduleArgs);
+            yield* Effect.tryPromise({
+                try: () => git.subModule(submoduleArgs()),
+                catch: (error) => {
+                    return new AppError({
+                        cause: error,
+                        message: "Failed to add submodule",
+                    });
+                }
+            })
+        } else {
+            logger.alert(`Submodule ${name} at ${clonePath} already registered. Skipping add.`);
+        }
+
+        yield* Effect.tryPromise({
+            try: () => git.submoduleUpdate(['--init', '--recursive', clonePath]),
+            catch: (error) => {
+                return new AppError({
+                    cause: error,
+                    message: "Failed to update submodule",
+                });
+            }
+        })
+        yield* Effect.tryPromise({
+            try: () => simpleGit({ baseDir: path.join(config.config.cwd, clonePath) }).checkout(repo.branch),
+            catch: (error) => {
+                return new AppError({
+                    cause: error,
+                    message: `Failed to checkout submodule ${repo} branch ${repo.branch}`,
+                });
+            }
+        })
+    }
+    logger.success("All modules processed!");
+
+})

package/src/commands/home.ts

@@ -0,0 +1,22 @@
+import { Effect } from "effect/index";
+import { Config } from "../config.js";
+import { FileSystem } from "@effect/platform"
+import { logger, orange } from "../utils/logger.js";
+import path, { join } from 'path';
+
+export const createLucyHome = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config
+        const fs = yield* FileSystem.FileSystem
+
+        if(!(yield* fs.exists(config.config.lucyHome))) {
+            logger.action(`Creating Lucy home directory at ${orange(config.config.lucyHome)}`);
+            yield* fs.makeDirectory(config.config.lucyHome, { recursive: true });
+        }
+        const templateFiles = yield* fs.readDirectory(config.config.filesFolder)
+        yield* Effect.forEach(
+            templateFiles,
+            (file) => fs.copy(path.join(config.config.filesFolder, file), path.join(config.config.lucyHome, file), { overwrite: true })
+        )
+    });
+}

package/src/commands/install.ts

@@ -0,0 +1,249 @@
+import { Command } from "@effect/platform/index";
+import { Effect, Schedule } from "effect/index";
+import { Config } from "../config.js";
+import { logger } from "../utils/logger.js";
+import { CommandExecutor, ExitCode } from "@effect/platform/CommandExecutor";
+import { PlatformError } from "@effect/platform/Error";
+
+export const installPackages = (workspace: boolean = false) => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+
+        const pkgs: string[] = []
+        for (const [key, value] of Object.entries(config.config.lucySettings.dependencies)) {
+            if (value.length > 0) {
+                pkgs.push(`${key}@${value}`);
+                continue
+            }
+            pkgs.push(key);
+        }
+        const devPkgs: string[] = []
+        for (const [key, value] of Object.entries(config.config.lucySettings.devDependencies)) {
+            if (value.length > 0) {
+                devPkgs.push(`${key}@${value}`);
+                continue
+            }
+            devPkgs.push(key);
+        }
+
+        const manager = config.config.lucySettings.packageManager;
+        function pkgMgrParamsInstall():string[] {
+            if (manager === "npm") {
+                return ["install"];
+            }
+            if (manager === "pnpm") {
+                return ["install"];
+            }
+            return ["add"];
+        }
+        function pkgMgrParamsInstallDev():string[] {
+            if (manager === "npm") {
+                return ["install", "-D"];
+            }
+            if (manager === "pnpm") {
+                return ["install", "-D"];
+            }
+            return ["add", "-D"];
+        }
+
+        function workspaceEnabled() {
+            if(config.config.lucySettings.packageManager === "pnpm" && workspace) {
+                return ["--workspace-root"];
+            }
+            return [];
+        }
+        logger.info("Installing dependencies");
+
+        const install = Command.make(
+            manager,
+                ...pkgMgrParamsInstall(),
+                ...workspaceEnabled(),
+                ...pkgs,
+            ).pipe(
+            Command.stdout("inherit"), // Stream stdout to process.stdout
+            Command.stderr("inherit"), // Stream stderr to process.stderr
+            Command.exitCode // Get the exit code
+        )
+
+        logger.info("Installing dev dependencies");
+        const installDev = Command.make(
+                manager,
+                ...pkgMgrParamsInstallDev(),
+                ...workspaceEnabled(),
+                ...devPkgs,
+            ).pipe(
+            Command.stdout("inherit"), // Stream stdout to process.stdout
+            Command.stderr("inherit"), // Stream stderr to process.stderr
+            Command.exitCode // Get the exit code
+        )
+
+        if(Object.keys(config.config.lucySettings.dependencies).length > 0) {
+            if ((yield* install) !== 0) {
+                return logger.error("Failed to install dependencies. Please check the error message above.");
+            }
+        }
+        if(Object.keys(config.config.lucySettings.devDependencies).length > 0) {
+            if ((yield* installDev) !== 0) {
+                return logger.error("Failed to install dev dependencies. Please check the error message above.");
+            }
+        }
+    })
+}
+
+export const runInstall = Effect.gen(function*() {
+        const config = yield* Config;
+
+    const manager = config.config.lucySettings.packageManager;
+    const install = Command.make(
+        manager,
+        "install",
+    ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.stderr("inherit"), // Stream stderr to process.stderr
+        Command.exitCode // Get the exit code
+    )
+    yield* install;
+})
+
+// export const yarnSetVersion = Effect.gen(function*() {
+//         const yarnDev = Command.make(
+//             "yarn",
+//             "set",
+//             "version",
+//             "berry",
+//         ).pipe(
+//         Command.stdout("inherit"), // Stream stdout to process.stdout
+//         Command.exitCode // Get the exit code
+//     )
+//     yield* yarnDev;
+// })
+export const installVeloPackages = Effect.gen(function*() {
+    const config = yield* Config;
+        const simpleSchedule = Schedule.tapOutput(
+            Schedule.fromDelays(50, 100, 200, 400, 800, 1600, 3200),
+            (n, ) => Effect.succeed(logger.warning(`Failed to install WIX package. Retrying...`))
+        );
+
+    const pkgs: string[] = []
+    for (const [key, value] of Object.entries(config.config.lucySettings.dependencies)) {
+        if (value.length > 0) {
+            pkgs.push(`${key}@${value}`);
+            continue
+        }
+        pkgs.push(key);
+    }
+
+    const wixPkgs: Effect.Effect<ExitCode, PlatformError, CommandExecutor>[] = []
+    const wixInstall = (cmd: Effect.Effect<ExitCode, PlatformError, CommandExecutor>) => Effect.gen(function*() {
+        const code = yield* Effect.retryOrElse(
+            Effect.gen(function*() {
+                const code = yield* cmd;
+                if (code !== 0) {
+                    return yield* Effect.fail(code);
+                }
+                return yield* Effect.succeed(code);
+            }), 
+            simpleSchedule,
+            () => Effect.succeed(0 as ExitCode)
+        )
+        if (code !== 0) {
+            logger.error("Failed to install WIX package.");
+        } 
+        return code;
+    })
+
+    for (const [key, value] of Object.entries(config.config.lucySettings.dependencies)) {
+        if (value.length > 0) {
+            wixPkgs.push(
+                wixInstall(
+                    Command.make(
+                        "wix",
+                        "install",
+                        `${key}@${value}`
+                ).pipe(
+                    Command.stdout("inherit"),
+                    Command.stderr("inherit"),
+                    Command.exitCode
+                )
+            )
+        )
+            continue
+        }
+        wixPkgs.push(
+            wixInstall(
+                Command.make(
+                    "wix",
+                    "install",
+                    `${key}`
+            ).pipe(
+                Command.stdout("inherit"),
+                Command.stderr("inherit"),
+                Command.exitCode
+            ),
+        ))
+    }
+
+    const devPkgs: string[] = []
+    for (const [key, value] of Object.entries(config.config.lucySettings.devDependencies)) {
+        if (value.length > 0) {
+            devPkgs.push(`${key}@${value}`);
+            continue
+        }
+        devPkgs.push(key);
+    }
+
+    const yarn = Command.make(
+            "yarn",
+            "add",
+            ...pkgs,
+        ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.exitCode // Get the exit code
+    )
+    const yarnDev = Command.make(
+            "yarn",
+            "add",
+            "-D",
+            ...devPkgs,
+        ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.exitCode // Get the exit code
+    )
+
+    logger.info("Installing dependencies with wix...");
+    const status = yield* Effect.all([...wixPkgs], { concurrency: 15});
+    if(status.every((s) => s !== 0)) {
+        return logger.error("Failed to install WIX dependencies. Please check the error message above.");
+    }
+
+    logger.info("Installing dependencies");
+    if ((yield* yarn) !== 0) {
+        return logger.error("Failed to install dependencies. Please check the error message above.");
+    }
+
+    logger.info("Installing dev dependencies");
+    if ((yield* yarnDev) !== 0) {
+        return logger.error("Failed to install dev dependencies. Please check the error message above.");
+    }
+
+})
+
+export const approveBuilds = Effect.gen(function*() {
+        const config = yield* Config;
+
+    const manager = config.config.lucySettings.packageManager;
+    const approve = Command.make(
+        "pnpm",
+        "approve-builds",
+    ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.stderr("inherit"), // Stream stderr to process.stderr
+        Command.stdin("inherit"),
+        Command.exitCode // Get the exit code
+    )
+    if (manager !== "pnpm") {
+        logger.warning("The 'approve-build' command is only available for pnpm. Skipping...");
+        return;
+    }
+    yield* approve;
+})

package/src/commands/read.ts

@@ -0,0 +1,45 @@
+import { Effect, Schema } from "effect/index";
+import { FileSystem, Path } from "@effect/platform"
+import { Config, lucyJsonName, packageJsonPath, veloSyncJsonPath } from "../config.js";
+import { JsonSchema, veloSyncSettings } from "../schemas/index.js";
+import { lucySettings } from "../schemas/lucy.js";
+import { logger } from "../utils/logger.js";
+
+export const readPackageJson = Effect.gen(function* () {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+
+    const packageJsonRaw = yield* fs.readFile(packageJsonPath)
+    config.config.packageJson = yield* Schema.decodeUnknown(JsonSchema)(packageJsonRaw.toString());
+})
+
+export const readLucyJsonFromTemplate = Effect.gen(function* () {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    
+    const lucyRaw = yield* fs.readFileString(path.join(config.config.templateDir, lucyJsonName));   
+    const lucySettingsJSON = yield* Schema.decodeUnknown(JsonSchema)(lucyRaw); 
+    const lucySetting = yield* Schema.decodeUnknown(lucySettings)(lucySettingsJSON)
+
+    if(config.config.lucySettings.initialized) {
+        if(config.config.force) {
+            logger.warning(`${lucyJsonName} already exists in the target directory, but 'force' is set. Overwriting...`);
+            config.config.lucySettings = lucySetting;
+            return;
+        }
+        logger.warning(`${lucyJsonName} already exists in the target directory. Skipping reading ${lucyJsonName} from template.`);
+        return;
+    }
+    config.config.lucySettings = lucySetting;
+})
+
+export const readVeloSyncSettings = Effect.gen(function* ()   {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    if (yield* fs.exists(veloSyncJsonPath)) {
+        const snyConfigRaw = yield* fs.readFileString(veloSyncJsonPath)
+        config.config.veloSyncSettings = yield* Schema.decodeUnknown(veloSyncSettings)(snyConfigRaw);
+    }
+});