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

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 swc from 'gulp-swc';
+import { logger } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.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,215 @@
+import * as fs from 'fs';
+import { glob } from 'glob';
+
+import * as path from 'path';
+import gulp from 'gulp';
+import ts from 'gulp-typescript';
+import { blue, logger, red, yellow } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.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){
+					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) {
+						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.success("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);
+}

package/src/tasks/gulp/clean.ts

@@ -0,0 +1,38 @@
+import gulp from 'gulp';
+import clean from 'gulp-clean';
+import { logger } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.js';
+
+export function cleanWix() {	
+    return () => {
+        return gulp.src('./.wix', { read: false, allowEmpty: true })
+		.pipe(clean({ force: true }))
+		.on('error', function (e: Error) {
+			logger.error('Cleaning of .wix failed!');
+			logger.error(`Error: ${e.message}`);
+
+
+			this.emit('end');
+		})
+		.on('end', function() { 
+			logger.success("Cleaning of .wix succeeded!");
+		});
+    }
+}
+
+export function cleanSrc(options: TaskOptions) {
+	const { outputDir } = options;
+
+	return () => {
+		return gulp.src([`${outputDir}/pages`, `${outputDir}/public`, `${outputDir}/backend`], { read: false, allowEmpty: true })
+		.pipe(clean({ force: true }))
+		.on('error', function (e: Error) {
+			logger.error('Cleaning of output files failed!');
+			logger.error(`Error: ${e.message}`);
+			this.emit('end');
+		})
+		.on('end', function() {
+			logger.success('Cleaning of .src succeeded!');
+		});
+	}
+}

package/src/tasks/gulp/copy.ts

@@ -0,0 +1,37 @@
+import gulp from 'gulp';
+import { logger } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.js';
+
+export function copyFiles(options: TaskOptions) {
+    const folders = ['typescript', ...options.modulesSourcePaths];
+    const tasks = folders.map((folder) => {
+		const { outputDir} = options;
+        const taskName = `copy-${folder}`; // Create a unique name for each task
+        const task = () =>
+			gulp.src([
+				`${folder}/**/*`, 
+				`!${folder}/*tsconfig.json`, 
+				`!${folder}/**/*.ts`, 
+				`!${folder}/**/*.tsx`, 
+				`!${folder}/types/**/**`, 
+				`!${folder}/__mocks__/**/**`, 
+				`!${folder}/styles/**`,
+			])
+			.pipe(gulp.dest(outputDir))
+                .on('error', function (e: Error) {
+                    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!`);
+                });
+
+        // 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/helpers.ts

@@ -0,0 +1,18 @@
+import { Effect } from 'effect/index';
+import { Config } from '../../config.js';
+
+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) {
+            if (data[module].path) {
+                paths.push(data[module].path);
+            } else {
+                paths.push(module);
+            }
+        }
+    }
+    return paths;
+});

package/src/tasks/gulp/pages.ts

@@ -0,0 +1,43 @@
+import gulp from 'gulp';
+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: {
+        target: 'es2020',
+        parser: {
+            syntax: "typescript",
+            tsx: true,
+        },
+        preserveAllComments: false,
+        minify: {
+            compress: true // equivalent to {}
+        }
+    },
+};
+
+export function buildPages(options: TaskOptions) {
+    const { outputDir} = options;
+
+    return () => {
+        return gulp.src('typescript/pages/*.ts')
+            .pipe(swc(swcOptions))
+                .on('error', function (e: Error) {
+                    logger.error('Build of Pages files failed!');
+                    logger.error(`Error: ${e.message}`);
+
+                    this.emit('end');
+                })
+                .pipe(gulp.dest(path.join(outputDir, 'pages')))
+                .on('error', function (e: Error) {
+                    logger.error('Build of Pages TS files failed!');
+                    logger.error(`Error: ${e.message}`);
+                    this.emit('end');
+                })
+                .on('end', function() {
+                    logger.success('Build of Pages TS files succeeded!');
+                });
+    };
+}

package/src/tasks/gulp/pipeline.ts

@@ -0,0 +1,31 @@
+import gulp from 'gulp';
+import * as path from 'path';
+import replace from 'gulp-string-replace';
+import { logger } from '../../utils/logger.js';
+import { File } from "../../schemas/gulp.js";
+export function setProdConfig() {
+    const tag = process.env.GIT_TAG || 'development';
+    const regexGit = /gitTag:\s*(.*),/g;
+    const regexDev = /devMode:\s*(.*),/g;
+
+    return () => {
+        return gulp
+            .src(['./typescript/public/constants/env.ts']) 
+            .pipe(replace(regexGit, `gitTag: '${tag}',`))
+            .pipe(replace(regexDev, `devMode: false,`))
+            .pipe(gulp.dest((file: File) => {
+                const filePath = file.dirname;
+                const outputDir = path.dirname(filePath);
+        
+                return path.join(`${outputDir}/constants`);
+            }))
+            .on('error', function (e: Error) {
+                logger.error('Setting the git tag failed!');
+                logger.error(`Error: ${e.message}`);
+                this.emit('end');
+            })
+            .on('end', function() {
+                logger.success('Setting the git tag succeeded!');
+            });
+    }
+}

package/src/tasks/gulp/public.ts

@@ -0,0 +1,60 @@
+import gulp from 'gulp';
+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: {
+        target: 'es2020',
+        parser: {
+            syntax: "typescript",
+            tsx: true,
+        },
+        preserveAllComments: false,
+        minify: {
+            compress: true // equivalent to {}
+        }
+    },
+};
+
+export function buildPublic(options: TaskOptions) {
+    const folders = ['typescript', ...options.modulesSourcePaths];
+
+    const { outputDir } = options;
+
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `build_Public-${folder}`; // Create a unique name for each task
+
+        const task = () =>
+            gulp.src([
+                `${folder}/public/**/*.ts`,
+                `${folder}/public/**/*.tsx`,
+            ])
+                .pipe(swc(swcOptions))
+                .on('error', function (e: Error) {
+                    logger.error(`Build of Public files for ${folder} failed!`);
+                    logger.error(`Error: ${e.message}`);
+
+                    this.emit('end');
+                })
+                .pipe(gulp.dest(path.join(outputDir, 'public')))
+                .on('error', function (e: Error) {
+                    logger.error(`Build of Public files for ${folder} failed!`);
+                    logger.error(`Error: ${e.message}`);
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    logger.success(`Build of Public 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/styles.ts

@@ -0,0 +1,46 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import { logger, orange } from '../../utils/logger.js';
+import { TaskOptions } from '../../schemas/gulp.js';
+
+export function compileScss(options: TaskOptions) {
+    const folders = ['typescript'];
+
+    const { sass, outputDir} = options;
+
+    const buildWixScss =  () => gulp.src(['typescript/styles/global.scss'], { allowEmpty: true })
+        .pipe(sass().on('error', sass.logError))
+        .on('error', function (e: Error) {
+            logger.error(`Build of SCSS files for ${orange('global.scs')} failed!`);
+            logger.error(`Error: ${orange(e.message)}`);
+            this.emit('end');
+        })
+        .pipe(gulp.dest(`${outputDir}/styles`))
+        .on('error', function (e: Error) {
+            logger.error(`Compiling of scss files for ${orange('global.scs')} failed!`);
+            logger.error(`Error: ${orange(e.message)}`);
+            this.emit('end');
+        })
+        .on('end', function () {
+            logger.success(`Compiling of scss files for ${orange('global.scs')} succeeded!`);
+        });
+
+    const buildScss =  () => gulp.src(['typescript/public/scss/app.scss'], { allowEmpty: true })
+        .pipe(sass().on('error', sass.logError))
+        .on('error', function (e: Error) {
+            logger.error(`Build of SCSS files for ${orange('app.scss')} failed!`);
+            logger.error(`Error: ${orange(e.message)}`);
+            this.emit('end');
+        })
+        .pipe(gulp.dest(`${outputDir}/public/css`))
+        .on('error', function (e: Error) {
+            logger.error(`Compiling of scss files for ${orange('app.scss')} failed!`);
+            logger.error(`Error: ${orange(e.message)}`);
+            this.emit('end');
+        })
+        .on('end', function () {
+            logger.success(`Compiling of scss files for ${orange('app.scss')} succeeded!`);
+        });
+        
+    return gulp.parallel(buildWixScss, buildScss);
+}

package/src/tasks/gulp/templates.ts

@@ -0,0 +1,53 @@
+import gulp from 'gulp';
+import { File, TaskOptions } from '../../schemas/gulp.js';
+import exec from 'gulp-exec';
+import { logger, orange } from '../../utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+
+export function previewTemplates(options: TaskOptions) {
+        const allFolders = ['typescript', ...options.modulesSourcePaths];
+        
+        // Filter folders to only include those that have a 'backend/templates' directory
+        const foldersWithTemplates = allFolders.filter(folder => {
+            const templateDir = path.join(folder, 'backend', 'templates');
+            return fs.existsSync(templateDir);
+        });
+
+        if (foldersWithTemplates.length === 0) {
+            logger.info("No template folders found to preview.");
+            // Return a Gulp task that does nothing.
+            return (done: () => void) => done();
+        }
+
+        const taskOpt = {
+            continueOnError: true,
+        };
+    
+        // Create tasks for each folder that has a template directory
+        const tasks = foldersWithTemplates.map((folder) => {
+            const taskName = `render_templates-${folder}`;
+            const task = () =>
+                gulp.src([
+                    `${folder}/backend/templates/**/*.tsx`, 
+                    `${folder}/backend/templates/data/*.json`, 
+                    `!${folder}/backend/templates/render.ts`,
+                ])
+                .pipe(exec((file: File) => `npx tsx --tsconfig ./local.tsconfig.json ${file.path}`, taskOpt))
+                    .on('error', function (e: Error) {
+                        logger.error(`Render of Template for ${orange(folder)} failed!`);
+                        logger.error(`Error: ${orange(e.message)}`);
+                        this.emit('end');
+                    })
+                    .on('end', function () {
+                        logger.success(`Render of Template for ${orange(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);
+}