lucy-cli 0.0.4

package/src/Gulpfile.ts

@@ -0,0 +1,271 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import glob from 'glob';
+import gulp from 'gulp';
+import clean from 'gulp-clean';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import exec from 'gulp-exec';
+import foreach from 'gulp-foreach';
+import * as insert from 'gulp-insert';
+import jeditor from 'gulp-json-editor';
+import rename from 'gulp-rename';
+import gulpSass from 'gulp-sass';
+import shell from 'gulp-shell';
+import replace from 'gulp-string-replace';
+import * as tap from 'gulp-tap';
+import ts from 'gulp-typescript';
+import * as wait from 'gulp-wait';
+import merge from 'merge-stream';
+import * as os from 'os';
+import * as path from 'path';
+import * as dartSass from 'sass';
+
+import backendSettings from '../settings/backend-settings.json' assert { type: 'json' };
+import masterSettings from '../settings/master-settings.json' assert { type: 'json' };
+import pageSettings from '../settings/page-settings.json' assert { type: 'json' };
+import publicSettings from '../settings/public-settings.json' assert { type: 'json' };
+
+import { buildPublic, buildPublicLib } from './gulp/public.js';
+import { buildBackend, buildBackendJSW } from './gulp/backend.js';
+import { checkPages, checkTs, checkTsLib } 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 { cleanWix } from './gulp/clean.js';
+import { addTypes, updateWixTypes } from './gulp/types.js';
+
+const sass = gulpSass(dartSass);
+
+export type TaskOptions = {
+	enableIncrementalBuild: boolean;
+	outputDir: string;
+	sass: ReturnType<typeof gulpSass>;
+	userHomeDir: string;
+	replaceOpions: typeof replaceOpions;
+	backendSettings: typeof backendSettings,
+	masterSettings: typeof masterSettings,
+	pageSettings: typeof pageSettings,
+	publicSettings: typeof publicSettings,
+	cwd: string;
+}
+
+export interface File {
+	path: string;
+	dirname: string;
+	// other properties...
+}
+
+let enableIncrementalBuild = false;
+const outputDir = './src';
+const userHomeDir = os.homedir();
+const replaceOpions = {
+	logs: {
+		enabled: false
+	}
+};
+
+const taskOptions: TaskOptions = { 
+	enableIncrementalBuild, 
+	outputDir, 
+	sass, 
+	userHomeDir, 
+	pageSettings, 
+	publicSettings, 
+	backendSettings, 
+	masterSettings, 
+	replaceOpions,
+	cwd: process.cwd(),
+}
+
+gulp.task('check-pages', gulp.parallel(
+	checkPages
+));
+
+gulp.task('check-ts', gulp.parallel( 
+	checkTs(),
+	checkTsLib(),
+));
+
+gulp.task('scss', gulp.parallel( 
+	compileScss(taskOptions),
+));
+
+gulp.task('build-jsw', gulp.parallel( 
+	buildBackendJSW(taskOptions),
+));
+
+gulp.task('build-backend', gulp.parallel( 
+	buildBackend(taskOptions),
+));
+
+gulp.task('build-public', gulp.parallel( 
+	buildPublic(taskOptions),
+	buildPublicLib(taskOptions),
+));
+
+gulp.task('build-pages', gulp.parallel(
+	buildPages(taskOptions),
+));
+
+gulp.task('preview-templates', gulp.parallel(
+	previewTemplates()
+));
+
+gulp.task('copy-files', gulp.parallel(
+	copyFiles(taskOptions)
+));
+
+gulp.task('clean-wix',gulp.parallel(
+	cleanWix()
+));
+
+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('clean-src', async () => {
+	return gulp.src([`${outputDir}/pages`, `${outputDir}/public`, `${outputDir}/backend`], { read: false, allowEmpty: true })
+		.pipe(clean({ force: true }))
+		.on('error', function () {
+			console.log(chalk.red.underline.bold('Cleaning of output files failed!'));
+			this.emit('end');
+		})
+		.on('end', function() { console.log(chalk.blueBright.underline('Cleaning of output files succeeded!')); });
+});
+
+gulp.task('set-production', function () {
+	const droneTag = process.env.DRONE_TAG || 'development';
+	const regexGit = /gitTag:\s*(.*),/g;
+	const regexDev = /devMode:\s*(.*),/g;
+
+	return gulp
+		.src(['./typescript/public/constants/config.ts']) 
+		.pipe(replace(regexGit, `gitTag: '${droneTag}',`))
+		.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 () {
+			console.log(chalk.red.underline.bold('Setting the git tag failed!'));
+			this.emit('end');
+		})
+		.on('end', function() { console.log(chalk.blueBright.underline('Setting the git tag succeeded!')); });
+});
+
+gulp.task('start-wix', shell.task([
+	'yarn wix:dev',
+]));
+
+gulp.task('test-watch', shell.task([
+	'sleep 10; yarn test --watch',
+]));
+
+gulp.task('test', shell.task([
+	'sleep 2; yarn test',
+]));
+
+gulp.task('gen-docs', shell.task([
+	'yarn docs',
+]));
+
+gulp.task('watch-scss', () => {
+	gulp.watch(['typescript/public/scss/**/*.scss'], gulp.series('scss'));
+});
+
+gulp.task('watch-jsw', () => {
+	enableIncrementalBuild = true;
+	gulp.watch(['typescript/backend/**/frontend.*.ts', 'wix-lucy-lib/backend/**/frontend.*.ts'], gulp.series('check-ts', 'build-jsw', 'test'));
+});
+gulp.task('watch-backend', () => {
+	enableIncrementalBuild = true;
+	gulp.watch([
+		'typescript/backend/**/*.ts', 
+		'typescript/backend/**/*.tsx', 
+		'!typescript/backend/**/*.spec.ts',
+	], gulp.series('check-ts', 'build-backend', 'test'));
+});
+gulp.task('watch-public', () => {
+	enableIncrementalBuild = true;
+	gulp.watch([
+		'typescript/public/**/*.ts', 
+		'typescript/public/**/*.tsx',
+		'wix-lucy-lib/src/public/**/*.ts', 
+		'wix-lucy-lib/src/public/**/*.tsx'
+	], gulp.series('check-ts', 'build-public', 'test'));
+});
+gulp.task('watch-templates', () => {
+	gulp.watch([
+		'typescript/backend/templates/**/*.tsx', 
+		'typescript/backend/templates/data/*.json', 
+		'!typescript/backend/templates/render.ts',
+	], gulp.series('preview-templates'));
+});
+
+gulp.task('watch-pages', () => {
+	enableIncrementalBuild = true;
+	gulp.watch('typescript/pages/**/*.ts', gulp.series('check-ts', 'build-pages', 'test'));
+});
+
+gulp.task('watch-files', () => {
+	enableIncrementalBuild = true;
+	gulp.watch([
+		'typescript/backend/**/*', 
+		'typescript/public/**/*', 
+		'typescript/pages/**/*', 
+		'!typescript/**/*.ts',
+	], gulp.series('copy-files'));
+});
+
+gulp.task('watch-types', () => {
+	enableIncrementalBuild = true;
+	gulp.watch(['./.wix/types/**/*.d.ts', '!./.wix/types/wix-code-types'], gulp.series('fix-wixtypes'));
+});
+
+gulp.task('fix-wix', gulp.series('clean-wix', 'sync-types', 'fix-wixtypes', 'add-wix-types'));
+gulp.task('clean', gulp.series('clean-src'));
+
+gulp.task('watch', gulp.parallel('watch-types', 'watch-jsw', 'watch-backend', 'watch-public', 'watch-pages', 'watch-files', 'watch-scss', 'watch-templates'));
+gulp.task('build-prod', gulp.series('clean', 'set-production', 'fix-wix', 'check-pages', 'build-jsw', 'build-backend', 'build-public', 'build-pages', 'copy-files', 'scss', 'gen-docs'));
+gulp.task('build', gulp.series('clean', 'fix-wix', 'check-ts', 'build-jsw', 'build-backend', 'build-public', 'build-pages', 'scss', 'copy-files'));
+
+gulp.task('fix-for-test', gulp.series('fix-wixtypes', 'add-wix-types'));
+gulp.task('build-pipeline', gulp.series('clean', 'set-production', 'build-jsw', 'build-backend', 'build-public', 'build-pages', 'copy-files', 'scss', 'gen-docs'));
+
+gulp.task('start-dev-env', gulp.parallel('watch', 'check-pages'));
+gulp.task('dev', gulp.series('build', 'start-dev-env', 'test-watch'));
+gulp.task('default', gulp.series('dev'));
+
+async function gulpTaskRunner(task: string) {
+	return new Promise(function (resolve, reject) {
+		gulp.series(task, (done) => {
+			resolve(true);
+			done();
+		})(function (err) {
+			console.log('gulpTaskRunner', err);
+			if (err) {
+				reject(err);
+			}
+		});
+	});
+}
+
+export async function runTask(task: string, cwd: string) {
+	console.log('runTask', {task, cwd});
+	taskOptions.cwd = cwd;
+	console.log('runTask', {task, cwd});
+	console.log('start');
+	await gulpTaskRunner(task);
+	console.log('end');
+}

package/src/dev.ts

@@ -0,0 +1,20 @@
+// https://www.sergevandenoever.nl/run-gulp4-tasks-programatically-from-node/
+import gulp from 'gulp';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export async function dev(cwd: string, arg: string[]) {
+    console.log('dev', {cwd, arg});
+    // Get the directory name of the current module
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    // Resolve the path to the Gulpfile
+    const gulpfilePath = path.resolve(__dirname, 'Gulpfile.js');
+
+    // Dynamically import the Gulpfile
+    const gulpfile = await import(`file://${gulpfilePath}`);
+
+    // Check if 'dev' task exists
+    gulpfile.runTask('dev', cwd)
+}

package/src/gulp/backend.ts

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import rename from 'gulp-rename';
+import * as path from 'path';
+import { TaskOptions } from '../Gulpfile';
+
+
+export function buildBackend(options: TaskOptions) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild,
+    });
+    return () => {
+        return gulp.src([
+            'typescript/backend/**/*.ts', 
+            'typescript/backend/**/*.tsx', 
+            '!typescript/backend/**/frontend.*.ts', 
+            '!typescript/backend/**/*.spec.ts',
+        ])
+            .pipe(gulpEsbuild({
+                bundle: false,
+            }))
+            .pipe(gulp.dest(path.join(outputDir, 'backend')))
+            .on('error', function () {
+                console.log(chalk.red.underline.bold('Build of Backend TS files failed!'));
+                this.emit('end');
+            })
+            .on('end', function() { console.log(chalk.blueBright.underline('Build of Backend TS files succeeded!')); 
+        }
+    )}
+}
+
+export function buildBackendJSW(options: TaskOptions) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild,
+    });
+    return () => {
+        return gulp.src(['typescript/backend/**/*.jsw.ts', 'wix-lucy-lib/backend/**/*.jsw.ts'])
+		.pipe(gulpEsbuild({
+			bundle: false,
+		}))
+		.pipe(rename({ extname: '.jsw' }))
+		.pipe(gulp.dest(path.join(outputDir, 'backend')))
+		.on('error', function () {
+			console.log(chalk.red.underline.bold('Build of JSW files failed!'));
+			this.emit('end');
+		})
+		.on('end', function() { console.log(chalk.blueBright.underline('Build of JSW files succeeded!'))});
+    }
+}

package/src/gulp/checks.ts

@@ -0,0 +1,127 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import glob from 'glob';
+import * as path from 'path';
+import gulp from 'gulp';
+import ts from 'gulp-typescript';
+
+/**
+ *  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
+ */
+function readFilesInFolder(folderPath: string, pattern: string | null, globPattern: string,) {
+	return new Promise((resolve, reject) => {
+		glob(path.join(folderPath, globPattern), (err: unknown, files: string[]) => {
+			if (err){
+				reject(err);
+
+				return;
+			}  
+			const filenameList: Object[] = [];
+			/**
+			 * Traverse files
+			 * @param {number} index Index
+			 */
+			function traverseFiles(index: number) {
+				if (index === files.length){
+					resolve(filenameList);
+					
+					return;
+				}
+				const file = files[index];
+				if(pattern){
+					if(!file) return
+					extractMatchFromFile(file, pattern)
+						.then((capturedGroup) => {
+							if (capturedGroup){
+								filenameList.push(capturedGroup);
+							}
+							traverseFiles(index + 1);
+						})
+						.catch(reject);
+				}
+				if(!pattern){
+					if(!file) return
+					filenameList.push(path.basename(file));
+					traverseFiles(index + 1);
+				}
+			}
+			traverseFiles(0);
+		});
+	});
+}
+
+export async function checkPages() {
+	console.log(chalk.blueBright.underline.bold('Checking pages...'));
+        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){
+            console.log(chalk.yellow.underline.bold('Missing in ts folder: '), '\n', missingInTs);
+            throw new Error('Missing in ts folder');
+        }
+        if (obsoleteInTs.length > 0){
+            console.log(chalk.yellow.underline.bold('Obsolete in ts folder'), '\n', obsoleteInTs);
+            throw new Error('Obsolete in ts folder');
+        }
+        if (missingInTs.length === 0 || obsoleteInTs.length === 0) console.log(chalk.blueBright.underline.bold('Files are insync!'));
+}
+
+export function checkTs() {
+    const tsProject = ts.createProject('./wix-lucy-lib/tsconfig.json', { noEmit: true });
+	
+    return () => {
+        return 	gulp.src(['wix-lucy-lib/typescript/**/*.ts', '!wix-lucy-lib/typescript/types/**/*.ts'], { cwd: 'typescript' })
+        .pipe(tsProject(ts.reporter.fullReporter()))
+        .on('error', function () {
+            console.log(chalk.red.underline.bold('Typescript (LIB) error!'));
+            this.emit('end');
+        })
+        .on('end', function () {
+            console.log(chalk.blueBright.underline('Typescript check succeeded!'));
+        });
+    };
+}
+
+export function checkTsLib() {
+    const tsProject = ts.createProject('./wix-lucy-lib/tsconfig.json', { noEmit: true });
+	
+    return () => {
+        return 	gulp.src(['wix-lucy-lib/typescript/**/*.ts', '!wix-lucy-lib/typescript/types/**/*.ts'], { cwd: 'typescript' })
+        .pipe(tsProject(ts.reporter.fullReporter()))
+        .on('error', function () {
+            console.log(chalk.red.underline.bold('Typescript (LIB) error!'));
+            this.emit('end');
+        })
+        .on('end', function () {
+            console.log(chalk.blueBright.underline('Typescript check (LIB) succeeded!'));
+        });
+    };
+}

package/src/gulp/clean.ts

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import rename from 'gulp-rename';
+import * as path from 'path';
+import { TaskOptions } from '../Gulpfile';
+import clean from 'gulp-clean';
+
+
+export function cleanWix() {
+    return () => {
+        return gulp.src('./.wix', { read: false, allowEmpty: true })
+		.pipe(clean({ force: true }))
+		.on('error', function () {
+			console.log(chalk.red.underline.bold('Cleaning of .wix failed!'));
+			this.emit('end');
+		})
+		.on('end', function() { console.log(chalk.blueBright.underline('Cleaning of .wix succeeded!')); });
+    }
+}
+

package/src/gulp/copy.ts

@@ -0,0 +1,26 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import { TaskOptions } from '../Gulpfile';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import * as path from 'path';
+
+export function copyFiles(options: TaskOptions) {
+    const { outputDir} = options;
+    return () => {
+        return gulp.src([
+			'typescript/**/*', 
+			'!typescript/*tsconfig.json', 
+			'!typescript/**/*.ts', 
+			'!typescript/**/*.tsx', 
+			'!typescript/types/**/**', 
+			'!typescript/__mocks__/**/**', 
+			'!typescript/public/scss/**',
+		])
+		.pipe(gulp.dest(outputDir))
+		.on('error', function () {
+			console.log(chalk.red.underline.bold('Copy of files failed!'));
+			this.emit('end');
+		})
+		.on('end', function() { console.log(chalk.blueBright.underline('Copy of files succeeded!')); });
+    }
+}

package/src/gulp/pages.ts

@@ -0,0 +1,25 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import { TaskOptions } from '../Gulpfile';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import * as path from 'path';
+
+export function buildPages(options: TaskOptions) {
+    const { outputDir, enableIncrementalBuild} = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild, // enables the esbuild's incremental build
+    });
+    
+    return () => {
+        return gulp.src('typescript/pages/*.ts')
+            .pipe(gulpEsbuild({
+                bundle: false,
+            }))
+            .pipe(gulp.dest(path.join(outputDir, 'pages')))
+            .on('error', function () {
+                console.log(chalk.red.underline.bold('Build of Pages TS files failed!'));
+                this.emit('end');
+            })
+            .on('end', function() { console.log(chalk.blueBright.underline('Build of Pages TS files succeeded!')); });
+    };
+}

package/src/gulp/public.ts

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import { createGulpEsbuild } from 'gulp-esbuild';
+
+import * as path from 'path';
+import { TaskOptions } from '../Gulpfile';
+
+
+export function buildPublic(options: TaskOptions) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild,
+    });
+    return () => {
+        return gulp.src([
+            'typescript/public/**/*.ts',
+            'typescript/public/**/*.tsx',
+        ])
+        .pipe(gulpEsbuild({
+            bundle: false,
+        }))
+        .pipe(gulp.dest(path.join(outputDir, 'public')))
+        .on('error', function () {
+        console.log(chalk.red.underline.bold('Build of Public TS files failed!'));
+        this.emit('end');
+        })
+        .on('end', function () {
+        console.log(chalk.blueBright.underline('Build of Public TS files succeeded!'));
+        });
+    };
+}
+export function buildPublicLib(options: TaskOptions) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild,
+    });
+    return () => {
+        return gulp.src([
+            'wix-lucy-lib/src/public/**/*.ts',
+            'wix-lucy-lib/src/public/**/*.tsx'
+        ])
+        .pipe(gulpEsbuild({
+            bundle: false,
+        }))
+        .pipe(gulp.dest(path.join(outputDir, 'public')))
+        .on('error', function () {
+        console.log(chalk.red.underline.bold('Build of Public (LIB) TS files failed!'));
+        this.emit('end');
+        })
+        .on('end', function () {
+        console.log(chalk.blueBright.underline('Build of Public (LIB) TS files succeeded!'));
+        });
+    };
+}
+
+

package/src/gulp/styles.ts

@@ -0,0 +1,20 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import { TaskOptions } from '../Gulpfile';
+
+
+export function compileScss(options: TaskOptions) {
+    const { sass, outputDir} = options;
+    return () => {
+        return 	gulp.src(['typescript/styles/global.scss' ])
+		.pipe(sass().on('error', sass.logError))
+		.pipe(gulp.dest(`${outputDir}/public/css`))
+        .on('error', function () {
+            console.log(chalk.red.underline.bold('Compiling of scss files failed!'));
+            this.emit('end');
+            })
+            .on('end', function () {
+            console.log(chalk.blueBright.underline('Compiling of scss files succeeded!'));
+            });
+    };
+}

package/src/gulp/templates.ts

@@ -0,0 +1,25 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import { File } from '../Gulpfile';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import * as path from 'path';
+import exec from 'gulp-exec';
+
+export function previewTemplates() {
+    const options = {
+        continueOnError: true,
+    };
+    return () => {
+        return gulp.src([
+            'typescript/backend/templates/**/*.tsx', 
+            'typescript/backend/templates/data/*.json', 
+            '!typescript/backend/templates/render.ts',
+        ])
+            .pipe(exec((file: File) => `npx ts-node-esm -T ${file.path}`, options))
+            .on('error', function () {
+                console.log(chalk.red.underline.bold('Render of Template failed!'));
+                this.emit('end');
+            })
+            .on('end', function() { console.log(chalk.blueBright.underline('Render of Template succeeded!')); });
+        };
+}