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

package/src/schemas/types.ts

@@ -0,0 +1,20 @@
+export const types = ["velo", "expo", "blocks", "monorepo", "tauri", "cargo", 'submodules'] as const;
+export const tasks = ["dev", "build", "build-prod", "build-pipeline"] as const;
+
+export type Action = 'init' | 'open' | 'task';
+
+export type Actions = {
+    action: Action;
+    type?: typeof types[number];
+    task?: typeof tasks[number];
+}
+
+export interface LucyArgs {
+    [x: string]: unknown;
+    // This will hold the command used, e.g., 'init'
+    _: Action[];
+    $0: string;
+    // Arguments for the 'init' command
+    type?: Actions['type'];
+    task?: Actions['task'];
+}

package/src/sync/sync.ts

@@ -0,0 +1,96 @@
+// import chalk, { modifierNames } from "chalk";
+// import readline from 'node:readline';
+// import {createDataSync, LoggingStatistics, LoggerRejectsReporter} from 'velo-sync';
+// import veloAPI from 'velo-sync/dist/velo/velo-api.js';
+// import syncTask from 'velo-sync/dist/tasks/sync-task.js';
+// import { readConfig, saveConfig, VeloSyncConfig } from "./helpers.js";
+// import optimist from 'optimist';
+// import migrateFileCache from 'velo-sync/dist/tasks/migrate-files-cache-task.js';
+// function printUsage() {
+//     console.log('Usage:  ');
+//     console.log('');
+//     console.log('Commands:');
+//     console.log('  init          generates a config file for the import / export / sync process');
+//     console.log('  is-alive      tests the config and the connection to the site');
+//     console.log('  sync          runs the sync process');
+//     console.log('  import        runs an import process');
+//     console.log('  migrate       migrate existing nedb cache to sqlite cache (.upload-cache.db => .upload-cache.sqlite.db)');
+// }
+
+// function syncOrImportTask(importOnly: boolean) {
+//     let argv = optimist
+//         .usage(`Usage: $0 ${importOnly ? 'import' : 'sync'} -f <scv filename> -c <collection>`)
+//         .demand('f')
+//         .alias('f', 'filename')
+//         .describe('f', 'csv filename to import')
+//         .demand('c')
+//         .describe('c', 'the name of the collection to import into')
+//         .alias('c', 'collection')
+//         .demand('s')
+//         .describe('s', 'schema file describing the fields of the collection')
+//         .alias('s', 'schema')
+//         .describe('dry', 'dry-run that does not upload any data or files, and does not remove or update anything on the site')
+//         .alias('dry', 'dryrun')
+//         .parse(process.argv.slice(3));
+//     let filename = argv.filename;
+//     let collection = argv.collection;
+//     let schema = argv.schema;
+//     let dryrun = argv.dryrun;
+//     //@ts-ignore
+//     syncTask.default(filename, collection, schema, importOnly, dryrun);
+// }
+
+// export async function sync() {
+
+//     if(moduleSettings.args.includes('-h') || moduleSettings.args.includes('help')) return printUsage();
+//     if(moduleSettings.args.includes('init')) {
+//         const rl = readline.createInterface({
+//             input: process.stdin,
+//             output: process.stdout,
+//             terminal: true
+//         });
+
+//         async function askQuestion(query: string):Promise<string> {
+//             return new Promise((resolve) => rl.question(query, (answer) => resolve(answer)));
+//         }
+
+//         console.log(chalk.yellow('hello to velo-sync init'));
+//         let siteUrl = await askQuestion(orange('what is the url of the site homepage? '));
+//         let secret = await askQuestion(orange('what is the velo-sync secret? '));
+//         rl.close();
+//         let config: VeloSyncConfig = { siteUrl, secret };
+//         await saveConfig(config, moduleSettings.veloConfigName);
+//         return console.log(chalk.green("🐕" + ' => config saved!'));
+// 	}
+
+//     if(moduleSettings.args.includes('is-alive')) {
+//         try {
+//             let config = await readConfig(moduleSettings.veloConfigName);
+//             console.log("🐕" + green(` => checking if the API for site ${chalk.greenBright(config.siteUrl)} is alive...`));
+//             await veloAPI.isAlive(config);
+//             return console.log(chalk.green("🐕" + ` => API of site ${chalk.greenBright(config.siteUrl)} is working and alive!!!`));
+//         }
+//         catch (e) {
+//             if(e instanceof Error)  {
+//                 return console.log((`💩 ${red.underline.bold("=> Failed to check endpoint")} ${orange(e.message)}`));
+//             }
+//         }
+//     }
+//     if(moduleSettings.args.includes('sync')) {
+//         return syncOrImportTask(false);
+//     }
+    
+//     if(moduleSettings.args.includes('import')) {
+//         return syncOrImportTask(true);
+//     }
+
+//     if(moduleSettings.args.includes('export')) {
+//         return console.log((`💩 ${red.underline.bold("=> Not implemented")}`));
+//     }
+    
+//     if(moduleSettings.args.includes('migrate')) {
+//         //@ts-ignore
+//         migrateFileCache.default();
+//     }
+
+// }

package/src/tasks/Gulpfile.ts

@@ -0,0 +1,252 @@
+import gulp from 'gulp';
+import gulpSass from 'gulp-sass';
+import shell from 'gulp-shell';
+import * as os from 'os';
+import * as dartSass from 'sass';
+import { join } from "path";
+
+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" };;
+
+import { buildPublic } from './gulp/public.js';
+import { buildBackend, buildBackendJSW } from './gulp/backend.js';
+import { checkPages, checkTs } from './gulp/checks.js';
+import { compileScss } from './gulp/styles.js';
+import { buildPages } from './gulp/pages.js';
+import { previewTemplates } from './gulp/templates.js';
+import { copyFiles } from './gulp/copy.js';
+import { cleanSrc, cleanWix } from './gulp/clean.js';
+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';
+
+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 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;
+	}
+	logger.report("Task completed successfully:", task);
+}

package/src/tasks/gulp/backend.ts

@@ -0,0 +1,112 @@
+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';
+
+const swcOptions = {
+    jsc: {
+        target: 'es2020',
+        parser: {
+            syntax: "typescript",
+            tsx: true,
+            decorators: true,
+            // preserveAllComments: true
+        },
+        preserveAllComments: false,
+        minify: {
+            compress: true // equivalent to {}
+        }
+    },
+};
+
+export function buildBackend(options: TaskOptions) {
+    const folders = ['typescript', ...options.modulesSourcePaths];
+
+    const { outputDir } = options;
+
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `build_Backend-${folder}`; // Create a unique name for each task
+
+        const task = () =>
+            gulp.src([
+                `${folder}/backend/**/*.ts`,
+                `${folder}/backend/**/*.tsx`,
+                `!${folder}/backend/**/*.jsw.ts`,
+                `!${folder}/backend/**/*.spec.ts`,
+            ])
+                .pipe(swc(swcOptions))
+                .on('error', function (e: Error) {
+                    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}`);
+
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    logger.success(` => Build of Backend files for ${folder} succeeded!`);
+                });
+
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
+    });
+
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
+}
+
+
+export function buildBackendJSW(options: TaskOptions) {
+    const folders = ['typescript', ...options.modulesSourcePaths];
+
+    const swcOptions = {
+        jsc: {
+            target: 'es6',
+        },
+    };
+    const { outputDir } = options;
+
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `build-${folder}`; // Create a unique name for each task
+
+        const task = () =>
+            gulp.src([
+                `${folder}/backend/**/*.jsw.ts`,
+            ])
+            .pipe(swc(swcOptions))
+            .on('error', function (e: Error) {
+                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}`);
+
+                this.emit('end');
+            })
+            .on('end', function () {
+                logger.success(` => Build of JSW files for ${folder} succeeded!`);
+            });
+
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
+    });
+
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
+}

package/src/tasks/gulp/checks.ts

@@ -0,0 +1,214 @@
+import * as fs from 'fs';
+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';
+
+// /**
+//  *  Extracts a match from a file
+//  * @param {string} filePath File path
+//  * @param {string} pattern Pattern to match
+//  */
+// function extractMatchFromFile(filePath: string, pattern: string) {
+// 	return new Promise((resolve, reject) => {
+// 		fs.readFile(filePath, 'utf8', (err, data) => {
+// 			if (err){
+// 				reject(err);
+				
+// 				return;
+// 			}
+// 			const regex = new RegExp(pattern);
+// 			const match = regex.exec(data);
+// 			const capturedGroup = match ? match.groups?.page : null;
+// 			resolve(capturedGroup);
+// 		});
+// 	});
+// }
+
+// async function readFilesInFolder(folderPath: string, pattern: string | null, globPattern: string): Promise<Object[]> {
+//     const files = await glob(path.join(folderPath, globPattern));
+//     const filenameList: Object[] = [];
+
+//     for (const file of files) {
+//         if (pattern) {
+//             const capturedGroup = await extractMatchFromFile(file, pattern);
+//             if (capturedGroup) {
+//                 filenameList.push(capturedGroup);
+//             }
+//         } else {
+//             filenameList.push(path.basename(file));
+//         }
+//     }
+
+//     return filenameList;
+// }
+
+/**
+ *  Extracts a match from a file
+ * @param {string} filePath File path
+ * @param {string} pattern Pattern to match
+ */
+function extractMatchFromFile(filePath: string, pattern: string) {
+	return new Promise((resolve, reject) => {
+		fs.readFile(filePath, 'utf8', (err, data) => {
+			if (err){
+				reject(err);
+				
+				return;
+			}
+			const regex = new RegExp(pattern);
+			const match = regex.exec(data);
+			const capturedGroup = match ? match.groups?.page : null;
+			resolve(capturedGroup);
+		});
+	});
+}
+
+/**
+ * Reads files in a folder
+ * @param {string} folderPath Folder path
+ * @param {string} pattern Pattern to match
+ * @param {string} globPattern Glob pattern
+ */
+async function readFilesInFolder(folderPath: string, pattern: string | null, globPattern: string,) {
+	const files = await glob.glob(path.join(folderPath, globPattern));
+	const filenameList: Object[] = [];
+	function traverseFiles(index: number) {
+		if (index === files.length){
+			return;
+		}
+		const file = files[index];
+		if(pattern){
+			if(!file) return
+			extractMatchFromFile(file, pattern)
+				.then((capturedGroup) => {
+					if (capturedGroup){
+						filenameList.push(capturedGroup);
+					}
+					traverseFiles(index + 1);
+				})
+				.catch(() => { throw new Error(`Error reading file: ${file}`); });
+		}
+		if(!pattern){
+			if(!file) return
+			filenameList.push(path.basename(file));
+			traverseFiles(index + 1);
+		}
+	}
+	traverseFiles(0);
+	
+	return filenameList;
+}
+export async function checkPages(fail: boolean, force: boolean) {
+	logger.action('Checking pages...');
+	return new Promise<void>(async (resolve, reject) => {
+		try {
+			const sourcePages = await readFilesInFolder('./.wix/types/', '\\/pages\\/(?<page>.*\\.ts)', '**/*.json',) as string[];
+			const tsPages = await readFilesInFolder('./typescript/pages', null, '**/*.ts',) as string[];
+
+			const sourcePagesSet = new Set(sourcePages);
+			const tsPagesSet = new Set(tsPages);
+			const missingInTs = Array.from(sourcePagesSet).filter((item: string) => !tsPages.includes(item));
+			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);
+				}
+				if(force) {
+					for (const page of missingInTs) {
+						logger.action('Creating missing page: ', page);
+						fs.writeFileSync(`./typescript/pages/${page}`, '');
+					}
+				}
+			}
+			if (obsoleteInTs.length > 0){
+				if(!force){
+					const formattedList = obsoleteInTs.map(page => `  • ${page}`).join('\n');
+						logger.error('Obsolete pages in TS folder:\n' + yellow(formattedList));
+					}
+				if(force) {
+					for (const page of obsoleteInTs) {
+						logger.action('Deleting obsolete page: ', page);
+						fs.rmSync(`./typescript/pages/${page}`);
+					}
+				}
+			}
+			if (missingInTs.length === 0 && obsoleteInTs.length === 0) {
+				logger.info("All pages are in-sync!");
+			} else if(fail){
+				process.exit(1);
+			};
+		} catch (error) {
+		reject(error);
+		}
+	});
+}
+
+const customReporter: ts.reporter.Reporter = {
+	error: (error, tsInstance) => {
+		if (!error.diagnostic) {
+			logger.error(error.message);
+			return;
+		}
+		const { fullFilename, startPosition } = error;
+		const relativePath = path.relative(process.cwd(), fullFilename ?? '');
+		const line = startPosition ? startPosition.line + 1 : 0;
+		const col = startPosition ? startPosition.character + 1 : 0;
+
+		const message = tsInstance.flattenDiagnosticMessageText(error.diagnostic.messageText, '\n');
+
+		logger.info(`${blue.underline(relativePath)}:${yellow(String(line))}:${yellow(String(col))}`);
+		logger.error(`  ${red('error')} ${yellow(`TS${error.diagnostic.code}`)}: ${message}`);
+	},
+	finish: (results) => {
+		const errorCount = results.transpileErrors + results.semanticErrors + results.declarationErrors;
+		if (errorCount > 0) {
+			logger.error(`\n${red.bold(`Found ${errorCount} error${errorCount > 1 ? 's' : ''}.`)}`);
+		}
+	},
+};
+
+export function checkTs(options: TaskOptions) {
+    const folders = ['typescript', ...options.modulesSourcePaths];
+
+
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+		const tsProject = ts.createProject(`./local.tsconfig.json`, { noEmit: true, declaration: false, skipDefaultLibCheck: true });
+
+        const taskName = `test-${folder}`; // Create a unique name for each task
+
+        const task = () => {
+            let hasError = false;
+            const stream = gulp.src([`${folder}/**/*.ts`, `!${folder}/types/**/*.ts`])
+                .pipe(tsProject(customReporter))
+                .on('error', () => {
+                    hasError = true;
+                });
+
+            if (options.isWatching) {
+                stream.on('error', function (this: NodeJS.ReadWriteStream) {
+                    this.emit('end');
+                });
+            }
+
+            stream.on('end', () => {
+                if (!hasError) {
+					logger.success(`Typescript check for ${folder} succeeded!`);
+                }
+            });
+
+            return stream;
+        };
+
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
+    });
+
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
+}