lucy-cli 2.0.0-alpha.2 → 2.0.0-alpha.20

package/src/init/monorepo.ts

@@ -0,0 +1,39 @@
+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 { runYarn, yarnSetVersion } from "../commands/install.js";
+import { cleanup } from "../commands/cleanup.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+
+export const init_monorepo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing monorepo...");
+
+        yield* checkForDirty();
+
+        yield* copyTemplateFiles;
+        yield* stringReplace(path.join(config.config.cwd, 'currents.config.ts'), ['__ProjectName__'], [config.config.projectName]);
+        yield* readPackageJson;
+        yield* setProjectName;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* gitInit();
+        yield* yarnSetVersion;
+        yield* runYarn;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Monorepo initialized successfully!");
+    })
+}

package/src/init/prepareVelo.ts

@@ -0,0 +1,19 @@
+import { Effect } from 'effect/index';
+import { logger } from '../utils/logger.js';
+import { checkForVelo } from '../commands/checks.js';
+import { gitInit } from '../commands/git.js';
+import { installVeloPackages, yarnSetVersion } from '../commands/install.js';
+import { setInitialized } from '../commands/edit.js';
+
+export const prepareVelo = Effect.gen(function*() {
+	logger.action("Initializing Tauri project...");
+	yield* checkForVelo();
+
+	yield* gitInit(true);
+	yield* yarnSetVersion;
+	yield* installVeloPackages
+	yield* setInitialized;
+	
+    logger.success("Velo Prepared initialized successfully!");
+
+})

package/src/init/tauri.ts

@@ -0,0 +1,40 @@
+import { Effect, Schema } from "effect/index"
+import { logger } from "../utils/logger.js";
+import { writeLucySettings } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+import { setInitialized } from "../commands/edit.js";
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { JsonSchema } from "../schemas/index.js";
+import { AppError } from "../error.js";
+import { installPackages } from "../commands/install.js";
+import { Terminal } from "@effect/platform"
+
+export const init_tauri = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        logger.action("Initializing Tauri project...");
+
+        yield* checkForDirty();
+
+        const initTauri = Command.make("yarn", "create", "tauri-app", config.config.projectName).pipe(
+            Command.stdin("inherit"),
+            Command.stdout("inherit"),
+            Command.stderr("inherit"),
+            Command.runInShell(true),
+            Command.exitCode
+        )
+        if((yield* initTauri) !== 0) {
+            yield* Effect.fail(new AppError({ message: "Failed to initialize Tauri project. Please check the error message above.", cause: new Error("Failed to initialize Tauri project") }));
+        }
+        yield* copyTemplateFiles;
+        yield* installPackages;
+        yield* writeLucySettings;
+        yield* gitInit();
+        yield* setInitialized;
+
+        logger.success("Tauri project initialized successfully!");
+    })
+}

package/src/init/templates.ts

@@ -0,0 +1,98 @@
+import { Effect, Schema } from "effect/index";
+import { Config, lucyJsonName, lucyJsonPath } from "../config.js";
+import { orange, red, green, logger } from "../utils/logger.js";
+import { FileSystem } from "@effect/platform"
+import path, { join } from 'path';
+import fsp from 'fs/promises';
+import Enquirer from 'enquirer';
+import { AppError } from "../error.js";
+import { lucySettings } from "../schemas/lucy.js";
+import { JsonSchema } from "../schemas/index.js";
+
+export const selectTemplate = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config
+        const fs = yield* FileSystem.FileSystem;
+        const templatesPath = join(config.config.lucyHome, 'templates');
+        const files = yield* Effect.tryPromise({
+            try: () => fsp.readdir(templatesPath, { withFileTypes: true }),
+            catch: (e) => {
+                console.log((`💩 ${red.underline.bold("=> Templates folder not found at =>")} ${orange(templatesPath)}`));
+                return new AppError({ cause: e, message: 'Templates folder not found' });
+            }
+        })
+                    
+        const templateChoices: string[] = [];
+        for (const dirent of files) {
+            if (dirent.isDirectory()) {
+                const lucyRaw = yield* fs.readFileString(lucyJsonPath);   
+                const lucySettingsJSON = yield* Schema.decodeUnknown(JsonSchema)(lucyRaw); 
+                const lucySetting = yield* Schema.decodeUnknown(lucySettings)(lucySettingsJSON)
+                if (lucySetting.type === config.config.action.initType) {
+                    templateChoices.push(dirent.name);
+                }
+            }
+        }
+
+        if (templateChoices.length === 0) {
+            console.log((`💩 ${red.underline.bold("=> No templates found in =>")} ${orange(templatesPath)}`));
+            return;
+        } 
+
+        const templateQuestion = new Enquirer();
+        const choice = yield* Effect.tryPromise({
+            try: () => templateQuestion.prompt({
+                type: 'select',
+                name: 'template',
+                message: 'Select a project template',
+                choices: templateChoices
+            }),
+            catch: (e) => {
+                return new AppError({ cause: e, message: 'Error selecting template' });
+            }
+        })
+
+    const selectedTemplate = yield* Schema.decodeUnknown(Schema.Struct({ template: Schema.String }))(choice)
+    const templateDir = join(templatesPath, selectedTemplate.template );
+    const templateFilesDir = join(templateDir, 'files');
+    config.config.templateDir = templateDir;
+    config.config.templateFiles = templateFilesDir;
+
+    const templateSettingsPath = join(templateDir, lucyJsonName);
+
+    if (!(yield* fs.exists(templateSettingsPath))) {
+        logger.warning((`💩 ${red.underline.bold(`Template is missing ${lucyJsonName} at =>`)} ${orange(templateSettingsPath)}`));
+        yield* Effect.fail(new AppError({ message: `Template is missing ${lucyJsonName}`, cause: templateSettingsPath }));
+    }
+    const lucySettingsRaw = yield* fs.readFileString(templateSettingsPath);
+    const newLucySettings = yield* Schema.decodeUnknown(lucySettings)(JSON.parse(lucySettingsRaw));
+    if( newLucySettings.type !== config.config.action.initType) return yield* Effect.fail(new AppError({
+        message: `Template type ${newLucySettings.type} does not match action type ${config.config.action.initType}`,
+        cause: newLucySettings.type
+    }));
+    if(config.config.lucySettings.initialized) {
+        const overwriteQuestion = new Enquirer();
+
+        const overwrite = yield* Effect.tryPromise({
+            try: () => overwriteQuestion.prompt({
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Overwrite existing ${lucyJsonName} settings?`,
+            }),
+            catch: (e) => {
+                return new AppError({
+                    cause: e,
+                    message: "Error overwriting settings",
+                });
+            }
+        })
+        const choice = yield* Schema.decodeUnknown(Schema.Struct({ overwrite: Schema.Boolean }))(overwrite);
+        if (choice.overwrite) {
+            config.config.lucySettings = newLucySettings;
+        } else {
+            logger.info(`Existing ${lucyJsonName} settings will be used.`);
+        }
+    }
+    logger.success(`Selected template: ${green(selectedTemplate.template)}`);
+    });
+}

package/src/init/velo.ts

@@ -0,0 +1,62 @@
+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, runYarn, 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";
+
+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* yarnSetVersion;
+        yield* installVeloPackages;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Velo initialized successfully!");
+    })
+}

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,15 @@
 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;

package/src/schemas/lucy.ts

@@ -0,0 +1,40 @@
+import { Schema } from "effect/index";
+import { initTypes } from "./types.js";
+
+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),
+}));
+
+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),
+	));
+
+	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-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);
+});