lucy-cli 2.0.0-alpha.9 → 2.0.0-beta.10

package/src/init/velo.ts

@@ -0,0 +1,66 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { FileSystem, Path } from "@effect/platform"
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized, setProjectName, stringReplace } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { installVeloPackages, runInstall, yarnSetVersion } from "../commands/install.js";
+import { cleanup } from "../commands/cleanup.js";
+import { gitInit } from "../commands/git.js";
+import { checkForVelo } from "../commands/checks.js";
+import { AppError } from "../error.js";
+import Enquirer from "enquirer";
+import { prepareVelo } from "./prepareVelo.js";
+import { openEditor } from "../commands/exec.js";
+
+export const init_velo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing Velo...");
+
+        yield* checkForVelo();
+
+        if(config.config.lucySettings.initialized && !config.config.force) {
+            const question = new Enquirer();
+            const choice = yield* Effect.tryPromise({
+                try: () => question.prompt({
+                    type: 'confirm',
+                    name: 'prepare',
+                    message: 'Do you want to prepare the velo project?(install packages, git init)',
+                }),
+                catch: (e) => {
+                    return new AppError({ cause: e, message: 'Error selecting template' });
+                }
+            })
+            const prepare = yield* Schema.decodeUnknown(Schema.Struct({ prepare: Schema.Boolean }))(choice)
+            if(prepare.prepare) return yield* prepareVelo
+        }
+
+
+        if(config.config.lucySettings.initialized && !config.config.force) return yield* Effect.fail(new AppError({ message: "Lucy is already initialized in this directory. Use --force to reinitialize.", cause: new Error("Lucy is already initialized in this directory") }));
+        if ((config.config.lucySettings.initialized && config.config.force) || (config.config.lucySettings.initialized && config.config.force)) logger.alert("Forced initialization!");
+        
+        yield* copyTemplateFiles;
+        yield* stringReplace(path.join(config.config.cwd, 'currents.config.js'), ['__ProjectName__'], [config.config.projectName]);
+        yield* readPackageJson;
+        yield* setProjectName;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* gitInit();
+        yield* runInstall;
+        yield* installVeloPackages;
+        yield* runInstall;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Velo initialized successfully!");
+
+        yield* openEditor;
+    })
+}

package/src/runtime.ts

@@ -18,3 +18,4 @@ export const build_runtime = (args: Awaited<ReturnType<typeof get_args>>) => {
         }))
     ))
 };
+

package/src/schemas/gulp.ts

@@ -0,0 +1,31 @@
+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 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;
+}
+
+export interface File {
+	path: string;
+	dirname: string;
+}

package/src/schemas/index.ts

@@ -1,3 +1,17 @@
 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;
+
+export const editors = ['vscode', 'cursor'] as const;

package/src/schemas/lucy.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect/index";
+import { initTypes } from "./types.js";
+
+export const pkgManagers = ['pnpm', 'yarn', 'npm'] as const;
+export const lucySettings = Schema.mutable(Schema.Struct({
+	modules: Schema.Record({
+        key: Schema.String, 
+        value: Schema.Struct({
+		source: Schema.String,
+		branch: Schema.String,
+		path: Schema.optional(Schema.String),
+		noCompile: Schema.optional(Schema.Boolean),
+	})}),
+	veloSettings: Schema.optional(Schema.NullOr(Schema.Struct({
+		compilerOptions: Schema.optional(Schema.Struct({
+			composite: Schema.Boolean,
+			noEmit: Schema.Boolean,
+			lib: Schema.Array(Schema.String),
+			jsx: Schema.String,
+		})),
+		exclude: Schema.optional(Schema.Array(Schema.String)),
+	}))),
+	initialized: Schema.Boolean,
+    type: Schema.Literal(...initTypes),
+	dependencies: Schema.mutable(Schema.Record({
+        key: Schema.String,
+        value: Schema.String,
+    })),
+	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),
+	packageManager: Schema.mutable(Schema.Literal(...pkgManagers)),
+	defaultModulePath: Schema.optional(Schema.String),
+}));
+
+export type LucySettings = typeof lucySettings.Type;

package/src/schemas/types.ts

@@ -0,0 +1,40 @@
+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';
+import gulp from 'gulp';
+
+export type SyncTaskType = (filename: string, collection: string, schemaFilename: string, importOnly: boolean, dryrun: boolean) => Promise<void>;
+export type MigrateFileCache = () => Promise<void>;
+export type TaskType = ReturnType< typeof gulp.parallel>
+
+export type Actions = {
+    action: Action;
+    initType?: typeof initTypes[number];
+    tasksName?: typeof taskNames[number];
+    syncAction?: typeof syncActions[number];
+    wixSDKAction?: typeof WixSDKActions[number];
+}
+
+export interface LucyArgs {
+    [x: string]: unknown;
+    // This will hold the command used, e.g., 'init'
+    _: Action[];
+    $0: string;
+    // Arguments for the 'init' command
+    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

@@ -0,0 +1,207 @@
+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 { logger } from '../utils/logger.js';
+import { Effect } from 'effect/index';
+import { Config } from '../config.js';
+import { AppError } from '../error.js';
+import { TaskOptions } from '../schemas/gulp.js';
+
+const sass = gulpSass(dartSass);
+
+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,
+	};
+
+	
+	logger.action(`Running task: ${task}`);
+
+	gulp.task('check-ts', gulp.parallel( 
+		checkTs(taskOptions, false),
+	));
+
+	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([
+		'wix sync-types',
+	]));
+
+	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([
+		'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

@@ -0,0 +1,113 @@
+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';
+import { TaskType } from '../../schemas/types.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): TaskType {
+    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): TaskType {
+    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);
+}