lucy-cli 2.0.0-alpha.12 → 2.0.0-alpha.14

package/src/config.ts

@@ -1,12 +1,13 @@
-import { Context, Layer, Schema } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 import { get_args } from "./args.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { readFileSync, existsSync } from "fs";
 import { lucySettings, LucySettings } from "./schemas/lucy.js";
-import { logger } from "./utils/logger.js";
 import os from 'os';
-import { Action, Actions } from "./schemas/types.js";
+import { Actions } from "./schemas/types.js";
+import { JsonSchema, veloSyncSettings, VeloSyncSettings, WixSDKSettings, wixSDKSettings } from "./schemas/index.js";
+import { FileSystem, Path } from "@effect/platform"
+import { NodeContext } from "@effect/platform-node/index";
 
 export class Config extends Context.Tag("Config")<
     Config,
@@ -17,6 +18,12 @@ export class Config extends Context.Tag("Config")<
             readonly cwd: string;
             readonly packageRoot: string;
             readonly filesFolder: string;
+            readonly veloSyncArguments?:{
+                    data?: string;
+                    collection?: string;
+                    schema?: string;
+                    dry: boolean;    
+            }
             packageJson: any;
             lucySettings: LucySettings;
             readonly lucyHome: string;
@@ -24,78 +31,112 @@ export class Config extends Context.Tag("Config")<
             templateFiles: string;
             projectName: string;
             defaultModuleBasePath: string;
+            veloSyncSettings?: VeloSyncSettings;
+            wixSDKSettings?: WixSDKSettings;
         }
     }
 >() {}
 
-// or, if you want just the inner config object:
-export type LucyConfig = typeof Config.Service["config"];
-
 // In an ES module, `__dirname` is not available by default.
 // We can replicate it using `import.meta.url`.
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-
-// Assuming your compiled output is in a 'dist' folder at the project root,
-// and your source `config.ts` is in `src`, the running `config.js` will be
-// in something like `dist/src`. To get to the package root, we go up two levels.
 const packageRoot = join(__dirname, "..");
 
+export const packageJsonName = "package.json";
+export const lucyJsonName = "lucy.json";
+export const wixSyncJsonName = "wix-sync.json";
+export const wixSDKSettingsJsonName = "wix-sdk-settings.json";
+export const syncDataName = 'sync-data';
+export const packageJsonPath = join(process.cwd(), packageJsonName);
+export const lucyJsonPath = join(process.cwd(), lucyJsonName);
+export const veloSyncJsonPath = join(process.cwd(), wixSyncJsonName);
+export const wixSDKSettingsJsonPath = join(process.cwd(), wixSDKSettingsJsonName);
+export const syncFilesSource= join(packageRoot, 'files', syncDataName);
+
+
 export const ConfigLayer = (args: Awaited<ReturnType<typeof get_args>>) => {
-    let packageJson = '{}';
-    let lucyJson: LucySettings | undefined = undefined;
-    const packageJsonPath = join(process.cwd(), 'package.json');
-    const lucyJsonPath = join(process.cwd(), 'lucy.json');
-    try {
-        if (existsSync(packageJsonPath)) {
-            const raw = readFileSync(packageJsonPath, 'utf-8');
-            packageJson = JSON.parse(raw);
-        }
-    } catch (error) {
-        logger.error("Error reading package.json:", error);
-    }
-    try {
-        if (existsSync(lucyJsonPath)) {
-            const raw = readFileSync(lucyJsonPath, 'utf-8');
-            lucyJson = Schema.decodeUnknownSync(lucySettings)(JSON.parse(raw));
-        }
-    } catch (error) {
-        logger.error("Error reading lucy.json:", error);
-    }
-    const defaultModulePath = () => {
-        if (args.type === 'monorepo') {
-            return join('packages');
-        }
-        return '';
-    }
-    return Layer.succeed(
+    return Layer.effect(
         Config,
-        Config.of({
-            config: {
-                action: {
-                    type: args.type,
-                    action: args._[0],
-                    task: args.task,
-                },
-                force: args.force === true ? true : false,
-                cwd: process.cwd(),
-                projectName: process.cwd().split('/').pop() || 'lucy-project',
-                packageRoot: packageRoot,
-                filesFolder: join(packageRoot, 'files'),
-                packageJson,
-                lucyHome: join(os.homedir(), '.lucy-cli'),
-                lucySettings: lucyJson || {
-                    modules: {},
-                    devDependencies: {},
-                    dependencies: {},
-                    scripts: {},
-                    initialized: false,
-                    type: args.type || 'velo',
-                },
-                templateFiles: '',
-                templateDir: '',
-                defaultModuleBasePath: defaultModulePath(),
+        Effect.gen(function* () {
+            const fs = yield* FileSystem.FileSystem;
+            const path = yield* Path.Path;
+            
+            let packageJson: any = {};
+            let lucyJson: LucySettings | undefined = undefined;
+            let veloSyncJson: VeloSyncSettings | undefined = undefined;
+            let wixSDKSettingsJson: WixSDKSettings | undefined = undefined;
+            // Read package.json
+            if (yield* fs.exists(packageJsonPath)) {
+                const raw = yield* fs.readFileString(packageJsonPath, 'utf-8');
+                packageJson = yield* Schema.decodeUnknown(JsonSchema)(raw);
+            }
+
+            // Read lucy.json
+            if (yield* fs.exists(lucyJsonPath)) {
+                const raw = yield* fs.readFileString(lucyJsonPath, 'utf-8');
+                const lucyJsonRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                lucyJson = yield* Schema.decodeUnknown(lucySettings)(lucyJsonRaw);
+            }
+
+            // Read wix-sync.json
+            if (yield* fs.exists(veloSyncJsonPath)) {
+                const raw = yield* fs.readFileString(veloSyncJsonPath, 'utf-8');
+                const veloSyncSettingsRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                veloSyncJson = yield* Schema.decodeUnknown(veloSyncSettings)(veloSyncSettingsRaw);
             }
-        })
+
+            // Read wix-sdk-settings.json
+            if (yield* fs.exists(wixSDKSettingsJsonPath)) {
+                const raw = yield* fs.readFileString(wixSDKSettingsJsonPath, 'utf-8');
+                const wixSDKSettingsRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                wixSDKSettingsJson = yield* Schema.decodeUnknown(wixSDKSettings)(wixSDKSettingsRaw);
+            }
+
+            const defaultModulePath = () => {
+                if (args.type === 'monorepo') {
+                    return join('packages');
+                }
+                return '';
+            };
+
+            return Config.of({
+                config: {
+                    action: {
+                        initType: args.initType,
+                        action: args._[0],
+                        tasksName: args.tasksName,
+                        syncAction: args.syncAction,
+                        wixSDKAction: args.wixSDKAction,
+                    },
+                    force: args.force === true ? true : false,
+                    cwd: process.cwd(),
+                    projectName: process.cwd().split('/').pop() || 'lucy-project',
+                    packageRoot,
+                    filesFolder: join(packageRoot, 'files'),
+                    packageJson,
+                    lucyHome: join(os.homedir(), '.lucy-cli'),
+                    veloSyncSettings: veloSyncJson,
+                    veloSyncArguments: {
+                        data: path.join(process.cwd(), args.input || ''),
+                        collection: args.collection,
+                        schema: path.join(process.cwd(), args.schema || ''),
+                        dry: args.d || false,
+                    },
+                    wixSDKSettings: wixSDKSettingsJson,
+                    lucySettings: lucyJson || {
+                        modules: {},
+                        devDependencies: {},
+                        dependencies: {},
+                        scripts: {},
+                        initialized: false,
+                        type: args.initType || 'velo',
+                    },
+                    templateFiles: '',
+                    templateDir: '',
+                    defaultModuleBasePath: defaultModulePath(),
+                }
+            });
+        }).pipe(Effect.provide(NodeContext.layer))
     );
-}
+}

package/src/helpers.ts

@@ -1,3 +1,7 @@
+import os from 'os';
+import { spawnSync, exec } from 'child_process';
+import { logger } from './utils/logger.js';
+
 export function parse_error(error: unknown): Error {
     if (error instanceof Error) {
         return error;
@@ -6,4 +10,90 @@ export function parse_error(error: unknown): Error {
     } else {
         return new Error('Unknown error');
     }
+}
+
+
+/**
+ * Kill all processes matching a specific substring in their command, with a fallback for Windows.
+ * @param {string} processPattern - The substring to match (e.g., "wix:dev" or "@wix/cli/bin/wix.cjs").
+ */
+export function killAllProcesses(processPattern: string) {
+    const isWindows = os.platform() === 'win32';
+    const command = isWindows
+        ? `tasklist /FI "IMAGENAME eq node.exe" /FO CSV | findstr "${processPattern}"` // Adjust for Node.js processes
+        : `ps -eo pid,command | grep "${processPattern}" | grep -v grep`;
+
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            logger.error(`Failed to find processes matching pattern: ${processPattern}`);
+            return;
+        }
+        if (stderr) {
+            logger.error(`Error output:')} ${stderr}`);
+        }
+        if (!stdout.trim()) {
+            logger.info(`No processes found matching pattern: ${processPattern}`);
+            return;
+        }
+
+        logger.info(`Found matching processes:\n${stdout}`);
+        const lines = stdout.trim().split('\n');
+        const pids = isWindows
+            ? lines.map(line => line.match(/"(\d+)"/)?.[1]) // Extract PID from Windows tasklist output
+            : lines.map(line => line.trim().split(/\s+/)[0]).filter(pid => !isNaN(Number(pid)));
+
+        pids.forEach(pid => {
+            if (!pid) return;
+            try {
+                const killCommand = isWindows
+                    ? `taskkill /PID ${pid} /T /F` // Forcefully terminate the process on Windows
+                    : `kill -SIGTERM ${pid}`;
+                
+                exec(killCommand, (killError) => {
+                    if (killError) {
+                        logger.error(`Failed to kill process with PID ${pid}: ${killError.message}`);
+                    } else {
+                        logger.success(`Killed process with PID: ${pid}`);
+                    }
+                });
+
+                // Schedule SIGKILL fallback for non-Windows platforms
+                if (!isWindows) {
+                    setTimeout(() => {
+                        try {
+                            process.kill(parseInt(pid, 10), 'SIGKILL');
+                            logger.kill(`Sent SIGKILL to process with PID: ${pid}`);
+                        } catch (killError: any) {
+                            if (killError.code === 'ESRCH') {
+                                logger.info(`Process with PID ${pid} already terminated.`);
+                            } else {
+                                logger.error(`Failed to send SIGKILL to process with PID ${pid}: ${killError.message}`);
+                            }
+                        }
+                    }, 10000);
+                }
+            } catch (err: any) {
+                logger.error(`Failed to kill process with PID ${pid}: ${err.message}`);
+            }
+        });
+    });
+}
+
+/**
+ * Clean up and run a command before exiting the process.
+ */
+export function cleanupWatchers() {
+    logger.info(`🧹 Cleaning up Watchman watchers...`);
+    const cwd = process.cwd();
+    const command = `watchman watch-del "${cwd}"`; // Adjust for Windows paths
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            logger.error(`Failed to run cleanup command: ${error.message}`);
+            return;
+        }
+        if (stderr) {
+            logger.error(`Watchman stderr: ${stderr}`);
+        }
+        logger.info(`Watchman cleanup success: ${stdout}`);
+    });
 }

package/src/index.ts

@@ -1,32 +1,73 @@
 #!/usr/bin/env node
-import { Chunk, Duration, Effect, pipe, Schedule, Array, Ref } from "effect";
+import { Effect, pipe} from "effect";
 import { build_runtime } from "./runtime.js";
 import { get_args } from "./args.js";
 import 'dotenv/config'
 import { Config } from "./config.js";
-import { ServiceInspectState } from "./states.js";
 import { init } from "./init/index.js";
 import { logger } from "./utils/logger.js";
-import { AppError } from "./error.js";
 import { open } from "./commands/exec.js";
-import { runTask } from "./tasks/Gulpfile.js";
 import { tasks } from "./tasks/index.js";
+import { cleanupWatchers, killAllProcesses } from "./helpers.js";
+import { wix_sync } from "./wix-sync/index.js";
+import { wix_sdk } from "./wix-sdk/index.js";
+
+let exitReason: 'SIGINT' | 'SIGTERM' | 'none' = 'none'
+let needsCleanup = false;
+
+export function setNeedsCleanup(value: boolean) {
+    needsCleanup = value;
+}
+process.on('exit', (code) => {
+    if(!needsCleanup) return;
+    if(exitReason === 'none') {
+	    killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+        killAllProcesses('wix:dev');   
+        cleanupWatchers();
+    }
+
+    logger.info(`🛑 Process exited with code: ${code}`);
+});
+
+process.on('SIGINT', () => {
+    exitReason = "SIGINT";
+
+	logger.info(`🐕 Received Ctrl+C (SIGINT), cleaning up...`);
+	killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+	killAllProcesses('wix:dev');  
+    cleanupWatchers();
+    process.exit(); // Exit explicitly after handling
+});
+
+process.on('SIGTERM', () => {
+    exitReason = "SIGTERM";
+
+	logger.info(`🛑 Received termination signal (SIGTERM), cleaning up...`);
+	killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+	killAllProcesses('wix:dev');  
+    cleanupWatchers();
+    process.exit(); // Exit explicitly after handling
+});
 
 const lucyCLI = pipe(
     Effect.gen(function* (_) {
         const config = yield* Config; 
         const t = Config; 
-        config.config.action.type;
         if (config.config.action.action === 'init') {
-            return yield* init();
+            return yield* init;
         }
         if (config.config.action.action === 'open') {
             return yield* open;
         }
         if (config.config.action.action === 'task') {
-            return yield* tasks();
+            return yield* tasks;
+        }
+        if (config.config.action.action === 'wix-sync') {
+            return yield* wix_sync;
+        }
+        if (config.config.action.action === 'wix-sdk') {
+            return yield* wix_sdk;
         }
-
     }),
 ).pipe(
     Effect.catchTags({
@@ -66,7 +107,6 @@ main().then(() => {
 }).catch((error) => {
     if (error instanceof Error) {
         logger.error(error.message);
-        console.debug(JSON.stringify(error, null, 2));
     }
     process.exit(1);
 });

package/src/init/blocks.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect/index"
-import { Config } from "../config.js";
+import { Config, lucyJsonName } from "../config.js";
 import { Command, FileSystem, Path } from "@effect/platform"
 import { JsonSchema } from "../schemas/index.js";
 import { logger } from "../utils/logger.js";
@@ -41,7 +41,7 @@ export const init_blocks = () => {
             }
             const files = yield * fs.readDirectory(config.config.cwd, { recursive: false });
 
-            const allExcludes = ['.git', 'lucy.json'];
+            const allExcludes = ['.git', lucyJsonName];
             const filteredFiles = files.filter(file => !allExcludes.includes(file));
 
             const t = yield* fs.stat(filteredFiles[0]);

package/src/init/index.ts

@@ -14,56 +14,50 @@ import { init_submodules } from "./gitModules.js";
 import { init_tauri } from "./tauri.js";
 
 
-export const init = () => {
-    return Effect.gen(function* (_) {
-        const config = yield* Config;
-        if(config.config.action.type === undefined) {
-            return yield* Effect.fail(new AppError({ message: "No action type provided", cause: new Error("No action type provided") }));
+export const init = Effect.gen(function* (_) {
+    const config = yield* Config;
+    if(config.config.action.initType === undefined) {
+        return yield* Effect.fail(new AppError({ message: "No init type provided", cause: new Error("No init type provided") }));
+    }
+    yield* createLucyHome();
+    const projectName = config.config.cwd.split('/').pop() || 'expo-project';
+    const templateQuestion = new Enquirer();
+    const choice = yield* Effect.tryPromise({
+        try: () => templateQuestion.prompt({
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter a project name',
+            initial: projectName,
+            validate: (value: string) => value.trim() !== '' ? true : 'Project name cannot be empty'
+        }),
+        catch: (e) => {
+            return new AppError({ cause: e, message: 'Error selecting template' });
         }
-        yield* createLucyHome();
-        const projectName = config.config.cwd.split('/').pop() || 'expo-project';
-
-        const templateQuestion = new Enquirer();
-        const choice = yield* Effect.tryPromise({
-            try: () => templateQuestion.prompt({
-                type: 'input',
-                name: 'projectName',
-                message: 'Enter a project name',
-                initial: projectName,
-                validate: (value: string) => value.trim() !== '' ? true : 'Project name cannot be empty'
-            }),
-            catch: (e) => {
-                return new AppError({ cause: e, message: 'Error selecting template' });
-            }
-        })
-        const selectedName = yield* Schema.decodeUnknown(Schema.Struct({ projectName: Schema.String }))(choice)
-        config.config.projectName = selectedName.projectName.trim();
-
-        yield* selectTemplate();
-        yield* readLucyJsonFromTemplate;
-
-        if(config.config.action.type === 'expo') {
-            return yield* init_expo();
-        }
-        if(config.config.action.type === 'monorepo') {
-            return yield* init_monorepo();
-        }
-        if(config.config.action.type === 'cargo') {
-            return yield* init_cargo();
-        }
-        if(config.config.action.type === 'blocks') {
-            return yield* init_blocks();
-        }
-        if(config.config.action.type === 'tauri') {
-            return yield* init_tauri();
-        }
-        if(config.config.action.type === 'velo') {
-            return yield* init_velo();
-        }
-        if(config.config.action.type === 'submodules') {
-            return yield* init_submodules();
-        }
-
-        yield* Effect.fail(new AppError({ message: `Unsupported action type: ${config.config.action.type}`, cause: new Error(`Unsupported action type: ${config.config.action.type}`) }));
     })
-}
+    const selectedName = yield* Schema.decodeUnknown(Schema.Struct({ projectName: Schema.String }))(choice)
+    config.config.projectName = selectedName.projectName.trim();
+    yield* selectTemplate();
+    yield* readLucyJsonFromTemplate;
+    if(config.config.action.initType === 'expo') {
+        return yield* init_expo();
+    }
+    if(config.config.action.initType === 'monorepo') {
+        return yield* init_monorepo();
+    }
+    if(config.config.action.initType === 'cargo') {
+        return yield* init_cargo();
+    }
+    if(config.config.action.initType === 'blocks') {
+        return yield* init_blocks();
+    }
+    if(config.config.action.initType === 'tauri') {
+        return yield* init_tauri();
+    }
+    if(config.config.action.initType === 'velo') {
+        return yield* init_velo();
+    }
+    if(config.config.action.initType === 'submodules') {
+        return yield* init_submodules();
+    }
+    yield* Effect.fail(new AppError({ message: `Unsupported init type: ${config.config.action.initType}`, cause: new Error(`Unsupported init type: ${config.config.action.initType}`) }));
+})

package/src/init/templates.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect/index";
-import { Config } from "../config.js";
+import { Config, lucyJsonName, lucyJsonPath } from "../config.js";
 import { orange, red, green, logger } from "../utils/logger.js";
 import { FileSystem } from "@effect/platform"
 import path, { join } from 'path';
@@ -25,11 +25,10 @@ export const selectTemplate = () => {
         const templateChoices: string[] = [];
         for (const dirent of files) {
             if (dirent.isDirectory()) {
-                const lucyJsonPath = join(templatesPath, dirent.name, 'lucy.json');
-                const lucyRaw = yield* fs.readFileString(lucyJsonPath, 'utf-8');   
+                const lucyRaw = yield* fs.readFileString(lucyJsonPath);   
                 const lucySettingsJSON = yield* Schema.decodeUnknown(JsonSchema)(lucyRaw); 
                 const lucySetting = yield* Schema.decodeUnknown(lucySettings)(lucySettingsJSON)
-                if (lucySetting.type === config.config.action.type) {
+                if (lucySetting.type === config.config.action.initType) {
                     templateChoices.push(dirent.name);
                 }
             }
@@ -59,16 +58,16 @@ export const selectTemplate = () => {
     config.config.templateDir = templateDir;
     config.config.templateFiles = templateFilesDir;
 
-    const templateSettingsPath = join(templateDir, 'lucy.json');
+    const templateSettingsPath = join(templateDir, lucyJsonName);
 
     if (!(yield* fs.exists(templateSettingsPath))) {
-        logger.warning((`💩 ${red.underline.bold("=> Template is missing lucy.json at =>")} ${orange(templateSettingsPath)}`));
-        yield* Effect.fail(new AppError({ message: 'Template is missing lucy.json', cause: templateSettingsPath }));
+        logger.warning((`💩 ${red.underline.bold(`Template is missing ${lucyJsonName} at =>`)} ${orange(templateSettingsPath)}`));
+        yield* Effect.fail(new AppError({ message: `Template is missing ${lucyJsonName}`, cause: templateSettingsPath }));
     }
-    const lucySettingsRaw = yield* fs.readFileString(templateSettingsPath, 'utf-8');
+    const lucySettingsRaw = yield* fs.readFileString(templateSettingsPath);
     const newLucySettings = yield* Schema.decodeUnknown(lucySettings)(JSON.parse(lucySettingsRaw));
-    if( newLucySettings.type !== config.config.action.type) return yield* Effect.fail(new AppError({
-        message: `Template type ${newLucySettings.type} does not match action type ${config.config.action.type}`,
+    if( newLucySettings.type !== config.config.action.initType) return yield* Effect.fail(new AppError({
+        message: `Template type ${newLucySettings.type} does not match action type ${config.config.action.initType}`,
         cause: newLucySettings.type
     }));
     if(config.config.lucySettings.initialized) {
@@ -78,7 +77,7 @@ export const selectTemplate = () => {
             try: () => overwriteQuestion.prompt({
                 type: 'confirm',
                 name: 'overwrite',
-                message: 'Overwrite existing lucy.json settings?',
+                message: `Overwrite existing ${lucyJsonName} settings?`,
             }),
             catch: (e) => {
                 return new AppError({
@@ -91,7 +90,7 @@ export const selectTemplate = () => {
         if (choice.overwrite) {
             config.config.lucySettings = newLucySettings;
         } else {
-            logger.info(`Existing lucy.json settings will be used.`);
+            logger.info(`Existing ${lucyJsonName} settings will be used.`);
         }
     }
     logger.success(`Selected template: ${green(selectedTemplate.template)}`);

package/src/schemas/gulp.ts

@@ -1,23 +1,32 @@
 import { LucySettings } from "./lucy";
 import * as dartSass from 'sass';
 import gulpSass from 'gulp-sass';
+import backendSettings from '../../settings/backend-settings.json' with { type: "json" };;
+import masterSettings from '../../settings/master-settings.json' with { type: "json" };;
+import pageSettings from '../../settings/page-settings.json' with { type: "json" };;
+import publicSettings from '../../settings/public-settings.json' with { type: "json" };;
 
 const sass = gulpSass(dartSass);
 
-export type ModuleSettings = {
-    packageRoot: string;
-    targetFolder: string;
-    wixConfigPath: string;
-    lucyConfigPath: string;
-    packageJsonPath: string;
-    settings: LucySettings;
-    force: boolean;
-    veloConfigName: string;
+export type TaskOptions = {
+    enableIncrementalBuild: boolean;
+    outputDir: string;
+    sass: ReturnType<typeof gulpSass>;
+    replaceOptions: {
+        logs: {
+            enabled: boolean;
+        }
+    };
+    backendSettings: typeof backendSettings,
+    masterSettings: typeof masterSettings,
+    pageSettings: typeof pageSettings,
+    publicSettings: typeof publicSettings,
+    modulesSourcePaths: string[];
+    cwd: string;
+    isWatching?: boolean;
 }
 
-export type ProjectSettings = {
-    // packages?: Record<string, string>;
-    modules?: Record<string, any>;
-    lucySettings?: LucySettings;
-    packageJSON?: Record<string, any>;
-}
+export interface File {
+	path: string;
+	dirname: string;
+}

package/src/schemas/index.ts

@@ -1,3 +1,14 @@
 import { Schema } from "effect/index";
 
-export const JsonSchema = Schema.parseJson()
+export const JsonSchema = Schema.parseJson()
+export const veloSyncSettings = Schema.Struct({
+	siteUrl: Schema.String,
+	secret: Schema.String,
+});
+export type VeloSyncSettings = typeof veloSyncSettings.Type;
+
+export const wixSDKSettings = Schema.Struct({
+	apiKey: Schema.String,
+	siteId: Schema.String,
+});
+export type WixSDKSettings = typeof wixSDKSettings.Type;