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

package/src/schemas/lucy.ts

@@ -1,7 +1,7 @@
 import { Schema } from "effect/index";
-import { types } from "./types.js";
+import { initTypes } from "./types.js";
 
-export const lucySettings = Schema.Struct({
+export const lucySettings = Schema.mutable(Schema.Struct({
 	modules: Schema.Record({
         key: Schema.String, 
         value: Schema.Struct({
@@ -20,20 +20,21 @@ export const lucySettings = Schema.Struct({
 		exclude: Schema.optional(Schema.Array(Schema.String)),
 	}))),
 	initialized: Schema.Boolean,
-    type: Schema.Literal(...types),
-	dependencies: Schema.Record({
+    type: Schema.Literal(...initTypes),
+	dependencies: Schema.mutable(Schema.Record({
         key: Schema.String,
         value: Schema.String,
-    }),
-	devDependencies: Schema.Record({
+    })),
+	devDependencies: Schema.mutable(Schema.Record({
         key: Schema.String,
         value: Schema.String,
-    }),
+    })),
 	scripts: Schema.Record({
         key: Schema.String,
         value: Schema.String,
     }),
 	additionalCommands: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
 	additionalPkgProps: Schema.optional(Schema.Object),
-});
+}));
+
 export type LucySettings = typeof lucySettings.Type;

package/src/schemas/types.ts

@@ -1,12 +1,18 @@
-export const types = ["velo", "expo", "blocks", "monorepo", "tauri", "cargo", 'submodules'] as const;
-export const tasks = ["dev", "build", "build-prod", "build-pipeline"] as const;
+export const initTypes = ["velo", "expo", "blocks", "monorepo", "tauri", "cargo", 'submodules', 'wix-sdk'] as const;
+export const taskNames = ["dev", "build", "build-prod", "build-pipeline", "sync-settings"] as const;
+export const syncActions = ["sync", "import", "init", "is-alive", "migrate", "export"] as const;
+export const WixSDKActions = ["init", ""] as const;
+export type Action = 'init' | 'open' | 'task' | 'wix-sync';
 
-export type Action = 'init' | 'open' | 'task';
+export type SyncTaskType = (filename: string, collection: string, schemaFilename: string, importOnly: boolean, dryrun: boolean) => Promise<void>;
+export type MigrateFileCache = () => Promise<void>;
 
 export type Actions = {
     action: Action;
-    type?: typeof types[number];
-    task?: typeof tasks[number];
+    initType?: typeof initTypes[number];
+    tasksName?: typeof taskNames[number];
+    syncAction?: typeof syncActions[number];
+    wixSDKAction?: typeof WixSDKActions[number];
 }
 
 export interface LucyArgs {
@@ -15,6 +21,18 @@ export interface LucyArgs {
     _: Action[];
     $0: string;
     // Arguments for the 'init' command
-    type?: Actions['type'];
-    task?: Actions['task'];
+    initType?: Actions['initType'];
+    tasksName?: Actions['tasksName'];
+    syncAction?: Actions['syncAction'];
+    wixSDKAction?: Actions['wixSDKAction'];
+    // wix-sync options
+    input?: string;        // Alias for -f
+    collection?: string;  // Alias for -c
+    schema?: string;      // Alias for -s
+    d?: boolean;    
 }
+
+export interface VeloSyncConfig {
+    siteUrl: string;
+    secret: string;
+}

package/src/tasks/Gulpfile.ts

@@ -22,231 +22,187 @@ import { addTypes, updateWixTypes } from './gulp/types.js';
 import { setProdConfig } from './gulp/pipeline.js';
 import { watchAll } from './gulp/watchers.js';
 import { getModulesSourcePaths } from './gulp/helpers.js';
-import { LucySettings } from '../schemas/lucy.js';
 import { logger } from '../utils/logger.js';
 import { Effect } from 'effect/index';
-import { ModuleSettings, ProjectSettings } from '../schemas/gulp.js';
-import { LucyConfig } from '../config.js';
+import { Config } from '../config.js';
+import { AppError } from '../error.js';
+import { TaskOptions } from '../schemas/gulp.js';
 
 const sass = gulpSass(dartSass);
 
-export type TaskOptions = {
-    moduleSettings?: ModuleSettings, 
-    projectSettings?: ProjectSettings
-    enableIncrementalBuild: boolean;
-    outputDir: string;
-    sass: ReturnType<typeof gulpSass>;
-    userHomeDir: string;
-    replaceOptions: typeof replaceOptions;
-    backendSettings: typeof backendSettings,
-    masterSettings: typeof masterSettings,
-    pageSettings: typeof pageSettings,
-    publicSettings: typeof publicSettings,
-    // modulesSync: Record<string, string> | undefined;
-    modulesSourcePaths: string[];
-    cwd: string;
-    isWatching?: boolean;
-}
-
-export interface File {
-	path: string;
-	dirname: string;
-	// other properties...
-}
-
-const outputDir = './src';
-const userHomeDir = os.homedir();
-const replaceOptions = {
-	logs: {
-		enabled: false
-	}
-};
-export const taskOptions: TaskOptions = { 
-	enableIncrementalBuild: false, 
-	outputDir, 
-	sass, 
-	userHomeDir, 
-	pageSettings, 
-	publicSettings, 
-	backendSettings, 
-	masterSettings, 
-	replaceOptions,
-	cwd: process.cwd(),
-	// modulesSync: getModulesSync(),
-	modulesSourcePaths: [],
-}
-
-const watchTaskOptions: TaskOptions = { ...taskOptions, isWatching: true };
-
-gulp.task('check-ts', gulp.parallel( 
-	checkTs(taskOptions),
-));
-
-gulp.task('scss', gulp.parallel( 
-	compileScss(taskOptions),
-));
-
-gulp.task('build-backend', gulp.parallel( 
-	buildBackend(taskOptions),
-	buildBackendJSW(taskOptions),
-	// buildBackendHTTP(taskOptions),
-));
-
-gulp.task('build-public', gulp.parallel( 
-	buildPublic(taskOptions),
-));
-
-gulp.task('preview-templates', gulp.parallel(
-	previewTemplates(taskOptions),
-));
-
-gulp.task('copy-files', gulp.parallel(
-	copyFiles(taskOptions),
-));
-
-gulp.task('test', function () {
-	return shell.task(
-		['yarn test'],
-		{ ignoreErrors: true }
-	)().then(() => {
-		logger.success("Tests completed successfully.");
-	}).catch(err => {
-		logger.error("Error in test task!");
-	});
-});
-gulp.task('test-ci', function () {
-	return shell.task(
-		['yarn test --run'],
-		{ ignoreErrors: true }
-	)().then(() => {
-		logger.success("Tests completed successfully.");
-	}).catch(err => {
-		logger.error("Error in test task!");
-	});
-});
-
-gulp.task('sync-types', shell.task([
-	'yarn postinstall',
-]));
-
-gulp.task('fix-wixtypes', gulp.parallel(
-	updateWixTypes(taskOptions)
-));
-
-gulp.task('add-wix-types', function(done: gulp.TaskFunctionCallback) {
-	return addTypes(taskOptions, done);
-});
-
-gulp.task('set-production', gulp.parallel(
-	setProdConfig()
-));
-
-gulp.task('start-wix', shell.task([
-	'yarn wix:dev',
-]));
-
-gulp.task('gen-docs', shell.task([
-	'yarn docs',
-]));
-
-gulp.task('fix-wix', gulp.series(
-	cleanWix(),
-	'sync-types', 
-	'fix-wixtypes', 
-	'add-wix-types'
-));
-
-gulp.task('build', gulp.parallel(
-	'build-backend', 
-	'build-public', 
-	'preview-templates',
-	buildPages(taskOptions),
-	compileScss(taskOptions), 
-	'copy-files'
-	)
-);
-
-gulp.task('build-pipeline', gulp.series(
-	cleanSrc(taskOptions),
-	'set-production',
-	'check-ts',
-	'fix-wixtypes', 
-	'add-wix-types',
-	'test-ci',
-	'build',
-));
-
-gulp.task('build-prod', gulp.series(
-	(done) => checkPages(true, false).then(() => done(), (err) => done(err)),
-	cleanSrc(taskOptions),
-	'set-production', 
-	'fix-wix', 
-	'check-ts',
-	'test-ci',
-	'build-backend', 
-	'build-public', 
-	buildPages(taskOptions),
-	'copy-files',
-	compileScss(taskOptions),
-	// 'gen-docs'
-));
-
-
-gulp.task('start-dev-env', gulp.parallel(
-	watchAll(watchTaskOptions),
-	'test',
-	// 'start-wix',
-	'check-ts',
-	(done) => checkPages(false, taskOptions.moduleSettings?.force ?? false).then(() => done(), (err) => done(err)),
-));
-
-gulp.task('dev', gulp.series(
-	cleanSrc(taskOptions),
-	'fix-wix',
-	'build',
-	'start-dev-env', 
-	)
-);
-
-async function gulpTaskRunner(task: string) {
-	return new Promise(function (resolve, reject) {
-		gulp.series(task, (done) => {
-			resolve(true);
-			done();
-		})(function (err) {
-			if (err) {
-				logger.error("Error starting tasks:", err);
-				reject(err);
+export const task_runGulp = Effect.gen(function* (_) {
+	const config = (yield* Config).config;
+	const task = config.action.tasksName || "dev";	
+
+	const taskOptions: TaskOptions = { 
+		enableIncrementalBuild: config.action.tasksName === 'dev' ? true : false, 
+		outputDir: './src', 
+		sass, 
+		pageSettings, 
+		publicSettings, 
+		backendSettings, 
+		masterSettings, 
+		replaceOptions: {
+			logs: {
+				enabled: false
 			}
+		},
+		cwd: process.cwd(),
+		modulesSourcePaths: yield* getModulesSourcePaths,
+		isWatching: config.action.tasksName === 'dev' ? true : false
+	};
+
+	
+	logger.action(`Running task: ${task}`);
+
+	gulp.task('check-ts', gulp.parallel( 
+		checkTs(taskOptions),
+	));
+
+	gulp.task('scss', gulp.parallel( 
+		compileScss(taskOptions),
+	));
+
+	gulp.task('build-backend', gulp.parallel( 
+		buildBackend(taskOptions),
+		buildBackendJSW(taskOptions),
+		// buildBackendHTTP(taskOptions),
+	));
+
+	gulp.task('build-public', gulp.parallel( 
+		buildPublic(taskOptions),
+	));
+
+	gulp.task('preview-templates', gulp.parallel(
+		previewTemplates(taskOptions),
+	));
+
+	gulp.task('copy-files', gulp.parallel(
+		copyFiles(taskOptions),
+	));
+
+	gulp.task('test', function () {
+		return shell.task(
+			['yarn test'],
+			{ ignoreErrors: true }
+		)().then(() => {
+			logger.success("Tests completed successfully.");
+		}).catch(err => {
+			logger.error("Error in test task!");
 		});
 	});
-}
-
-export async function runTask(config: LucyConfig) {
-	taskOptions.cwd = config.cwd;
-	taskOptions.moduleSettings = {
-		packageRoot: config.packageRoot,
-		targetFolder: config.cwd,
-		force: config.force,
-		lucyConfigPath: join(config.cwd, "lucy.json"),
-		packageJsonPath: join(config.cwd, "package.json"),
-		settings: config.lucySettings,
-		wixConfigPath: join(config.cwd, "wix.config.json"),
-		veloConfigName: join(config.cwd, "jsconfig.json"),
-	};
-	taskOptions.modulesSourcePaths = getModulesSourcePaths(config);
-	taskOptions.projectSettings = {
-		modules: config.lucySettings.modules,
-        lucySettings: config.lucySettings,
-        packageJSON: config.packageJson, 
-	};
-	const task = config.action.task || "dev";
-	logger.action(`Running task: ${task} with options:`, taskOptions);
-	try {
-	await gulpTaskRunner(task || 'dev');
-	} catch (err) {
-		logger.error("Error starting tasks:", err);
-		throw err;
-	}
+	gulp.task('test-ci', function () {
+		return shell.task(
+			['yarn test --run'],
+			{ ignoreErrors: true }
+		)().then(() => {
+			logger.success("Tests completed successfully.");
+		}).catch(err => {
+			logger.error("Error in test task!");
+		});
+	});
+
+	gulp.task('sync-types', shell.task([
+		'yarn postinstall',
+	]));
+
+	gulp.task('fix-wix-types', gulp.parallel(
+		updateWixTypes(taskOptions)
+	));
+
+	gulp.task('add-wix-types', function(done: gulp.TaskFunctionCallback) {
+		return addTypes(taskOptions, done);
+	});
+
+	gulp.task('set-production', gulp.parallel(
+		setProdConfig()
+	));
+
+	gulp.task('start-wix', shell.task([
+		'yarn wix:dev',
+	]));
+
+	gulp.task('gen-docs', shell.task([
+		'yarn docs',
+	]));
+
+	gulp.task('fix-wix', gulp.series(
+		cleanWix(),
+		'sync-types', 
+		'fix-wix-types', 
+		'add-wix-types'
+	));
+
+	gulp.task('build', gulp.parallel(
+		'build-backend', 
+		'build-public', 
+		'preview-templates',
+		buildPages(taskOptions),
+		compileScss(taskOptions), 
+		'copy-files'
+		)
+	);
+
+	gulp.task('build-pipeline', gulp.series(
+		cleanSrc(taskOptions),
+		'set-production',
+		'check-ts',
+		'fix-wix-types', 
+		'add-wix-types',
+		'test-ci',
+		'build',
+	));
+
+	gulp.task('build-prod', gulp.series(
+		(done) => checkPages(true, false).then(() => done(), (err) => done(err)),
+		cleanSrc(taskOptions),
+		'set-production', 
+		'fix-wix', 
+		'check-ts',
+		'test-ci',
+		'build-backend', 
+		'build-public', 
+		buildPages(taskOptions),
+		'copy-files',
+		compileScss(taskOptions),
+		// 'gen-docs'
+	));
+
+	gulp.task('start-dev-env', gulp.parallel(
+		watchAll(taskOptions),
+		'test',
+		'start-wix',
+		'check-ts',
+		(done) => checkPages(false, config.force).then(() => done(), (err) => done(err)),
+	));
+
+	gulp.task('dev', gulp.series(
+		cleanSrc(taskOptions),
+		'fix-wix',
+		'build',
+		'start-dev-env', 
+		)
+	);
+
+	yield* Effect.tryPromise({
+		try: () =>  {
+			return new Promise(function (resolve, reject) {
+				gulp.series(task, (done) => {
+					resolve(true);
+					done();
+				})(function (err) {
+					if (err) {
+						logger.error("Error starting tasks:", err);
+						reject(err);
+					}
+				});
+			});
+		},
+		catch: (e) => {
+			logger.error("Error starting tasks:", e);
+			return new AppError({ message: 'Error starting tasks', cause: e });
+		}
+	})
+
 	logger.report("Task completed successfully:", task);
-}
+});

package/src/tasks/gulp/backend.ts

@@ -1,9 +1,9 @@
 import gulp from 'gulp';
 import rename from 'gulp-rename';
 import * as path from 'path';
-import { TaskOptions } from '../Gulpfile.js';
 import swc from 'gulp-swc';
 import { logger } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.js';
 
 const swcOptions = {
     jsc: {
@@ -39,20 +39,20 @@ export function buildBackend(options: TaskOptions) {
             ])
                 .pipe(swc(swcOptions))
                 .on('error', function (e: Error) {
-                    logger.error(` => Build of Backend files for ${folder} failed!`);
-                    logger.error(` => Error: ${e.message}`);
+                    logger.error(`Build of Backend files for ${folder} failed!`);
+                    logger.error(`Error: ${e.message}`);
 
                     this.emit('end');
                 })
                 .pipe(gulp.dest(path.join(outputDir, 'backend')))
                 .on('error', function (e: Error) {
-                    logger.error(` => Build of Backend files for ${folder} failed!`);
-                    logger.error(` => Error: ${e.message}`);
+                    logger.error(`Build of Backend files for ${folder} failed!`);
+                    logger.error(`Error: ${e.message}`);
 
                     this.emit('end');
                 })
                 .on('end', function () {
-                    logger.success(` => Build of Backend files for ${folder} succeeded!`);
+                    logger.success(`Build of Backend files for ${folder} succeeded!`);
                 });
 
         // Register the task with Gulp
@@ -85,21 +85,21 @@ export function buildBackendJSW(options: TaskOptions) {
             ])
             .pipe(swc(swcOptions))
             .on('error', function (e: Error) {
-                logger.error(` => Build of JSW files for ${folder} failed!`);
-                logger.error(` => Error: ${e.message}`);
+                logger.error(`Build of JSW files for ${folder} failed!`);
+                logger.error(`Error: ${e.message}`);
 
                 this.emit('end');
             })
             .pipe(rename({ extname: '' }))
             .pipe(gulp.dest(path.join(outputDir, 'backend')))
             .on('error', function (e: Error) {
-                logger.error(` => Build of JSW files for ${folder} failed!`);
-                logger.error(` => Error: ${e.message}`);
+                logger.error(`Build of JSW files for ${folder} failed!`);
+                logger.error(`Error: ${e.message}`);
 
                 this.emit('end');
             })
             .on('end', function () {
-                logger.success(` => Build of JSW files for ${folder} succeeded!`);
+                logger.success(`Build of JSW files for ${folder} succeeded!`);
             });
 
         // Register the task with Gulp

package/src/tasks/gulp/checks.ts

@@ -4,8 +4,8 @@ import { glob } from 'glob';
 import * as path from 'path';
 import gulp from 'gulp';
 import ts from 'gulp-typescript';
-import { TaskOptions } from '../Gulpfile.js';
 import { blue, logger, red, yellow } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.js';
 
 // /**
 //  *  Extracts a match from a file
@@ -115,7 +115,8 @@ export async function checkPages(fail: boolean, force: boolean) {
 			const obsoleteInTs = Array.from(tsPagesSet).filter((item: string) => !sourcePages.includes(item));
 			if (missingInTs.length > 0){
 				if(!force){
-					logger.error('Missing pages in ts folder:', '\n', missingInTs);
+					const formattedList = missingInTs.map(page => `  • ${page}`).join('\n');
+						logger.error('Missing pages in ts folder::\n' + yellow(formattedList));
 				}
 				if(force) {
 					for (const page of missingInTs) {
@@ -137,7 +138,7 @@ export async function checkPages(fail: boolean, force: boolean) {
 				}
 			}
 			if (missingInTs.length === 0 && obsoleteInTs.length === 0) {
-				logger.info("All pages are in-sync!");
+				logger.success("All pages are in-sync!");
 			} else if(fail){
 				process.exit(1);
 			};

package/src/tasks/gulp/clean.ts

@@ -1,7 +1,7 @@
 import gulp from 'gulp';
-import { TaskOptions } from '../Gulpfile.js';
 import clean from 'gulp-clean';
 import { logger } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.js';
 
 export function cleanWix() {	
     return () => {
@@ -28,7 +28,7 @@ export function cleanSrc(options: TaskOptions) {
 		.pipe(clean({ force: true }))
 		.on('error', function (e: Error) {
 			logger.error('Cleaning of output files failed!');
-			logger.error(` => Error: ${e.message}`);
+			logger.error(`Error: ${e.message}`);
 			this.emit('end');
 		})
 		.on('end', function() {

package/src/tasks/gulp/copy.ts

@@ -1,16 +1,12 @@
 import gulp from 'gulp';
-import { TaskOptions } from '../Gulpfile.js';
 import { logger } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.js';
 
 export function copyFiles(options: TaskOptions) {
     const folders = ['typescript', ...options.modulesSourcePaths];
-
-    // Create tasks for each folder
     const tasks = folders.map((folder) => {
 		const { outputDir} = options;
-
         const taskName = `copy-${folder}`; // Create a unique name for each task
-
         const task = () =>
 			gulp.src([
 				`${folder}/**/*`, 
@@ -23,14 +19,12 @@ export function copyFiles(options: TaskOptions) {
 			])
 			.pipe(gulp.dest(outputDir))
                 .on('error', function (e: Error) {
-                    logger.error(` => Copy of files for ${folder} failed!`);
-                    logger.error(` => Error: ${e.message}`);
-
-                    
+                    logger.error(`Copy of files for ${folder} failed!`);
+                    logger.error(`Error: ${e.message}`);
                     this.emit('end');
                 })
                 .on('end', function () {
-                    logger.success(` => Copy of files for ${folder} succeeded!`);
+                    logger.success(`Copy of files for ${folder} succeeded!`);
                 });
 
         // Register the task with Gulp

package/src/tasks/gulp/helpers.ts

@@ -1,16 +1,9 @@
+import { Effect } from 'effect/index';
+import { Config } from '../../config.js';
 
-// import * as path from 'path';
-// import * as fs from 'fs';
-import { LucyConfig } from '../../config.js';
-
-// export function getModulesSync(): Record<string, string> | undefined {
-//     const absolutePath = path.resolve('./lucy.json');
-//     const fileContent = fs.readFileSync(absolutePath, 'utf8') as any;
-//     return JSON.parse(fileContent).modules;
-// }
-
-export function getModulesSourcePaths(config: LucyConfig): string[] {
-    const data =  config.lucySettings.modules;
+export const getModulesSourcePaths = Effect.gen(function* () {
+    const config = yield* Config
+    const data = config.config.lucySettings.modules;
     const paths: string[] = [];
     for (const module of Object.keys(data)) {
         if (!data[module].noCompile) {
@@ -22,4 +15,4 @@ export function getModulesSourcePaths(config: LucyConfig): string[] {
         }
     }
     return paths;
-}
+});

package/src/tasks/gulp/pages.ts

@@ -1,8 +1,8 @@
 import gulp from 'gulp';
-import { TaskOptions } from '../Gulpfile.js';
 import * as path from 'path';
 import swc from 'gulp-swc';
 import { logger } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.js';
 
 const swcOptions = {
     jsc: {