@joystick.js/cli-canary 0.0.0-canary.172 → 0.0.0-canary.1721

package/src/lib/build/index.js

@@ -0,0 +1,137 @@
+import chalk from "chalk";
+import child_process from "child_process";
+import fs from 'fs';
+import { dirname } from 'path';
+import util from 'util';
+import build_files from "./build_files.js";
+import get_files_to_build from "./get_files_to_build.js";
+import get_file_operation from "./get_file_operation.js";
+import get_path_platform from "./get_path_platform.js";
+import get_tar_ignore_list from "./get_tar_ignore_list.js";
+import load_settings from "../load_settings.js";
+import Loader from "../loader.js";
+import path_exists from "../path_exists.js";
+import encrypt_buffer from '../../lib/encrypt_buffer.js';
+
+const { mkdir, copyFile, readFile, writeFile, readdir } = fs.promises;
+const exec = util.promisify(child_process.exec);
+
+const get_custom_copy_paths = async (copy_paths_from_settings = []) => {
+  const custom_copy_paths = [];
+
+  for (let i = 0; i < copy_paths_from_settings?.length; i += 1) {
+    const custom_copy_path = copy_paths_from_settings[i];
+
+    if (fs.existsSync(custom_copy_path)) {
+      const stat = fs.lstatSync(custom_copy_path);
+
+      if (stat.isDirectory()) {
+        const paths = await readdir(custom_copy_path, { recursive: true });
+        custom_copy_paths.push(
+          ...(paths || [])?.map((path) => {
+            return `${custom_copy_path}/${path}`;
+          })
+        );
+      } else {
+        custom_copy_paths.push(custom_copy_path);
+      }
+    }
+  }
+
+  return custom_copy_paths;
+};
+
+const get_files_to_build_with_operation_and_platform = (files = []) => {
+  return files?.map((file) => {
+    return {
+      path: file,
+      operation: get_file_operation(file),
+      platform: get_path_platform(file),
+    }
+  });
+};
+
+const build = async (options = {}) => {
+  const loader = new Loader();
+
+  const build_type = options?.type || 'tar';
+  const environment = options?.environment || "production";
+
+  loader.print(`Building app to ${build_type} for ${environment}...`);
+
+  const settings = await load_settings(environment);
+  const excluded_paths = settings?.config?.build?.excluded_paths || settings?.config?.build?.excludedPaths;
+  const custom_copy_paths = await get_custom_copy_paths(settings?.config?.build?.copy_paths);
+
+  const files_for_build = await get_files_to_build(excluded_paths, custom_copy_paths);
+  const output_path = build_type === 'tar' ? '.build/.tar' : '.build';
+  const files_to_build_with_operation_and_platform = get_files_to_build_with_operation_and_platform(files_for_build);
+
+  if (await path_exists('.build')) {
+    await exec(`rm -rf .build`);
+  }
+
+  const files_to_copy = [
+    ...files_to_build_with_operation_and_platform?.filter((file) => {
+      return file?.operation === 'copy_file';
+    }),
+    ...(custom_copy_paths || [])?.map((custom_copy_path) => {
+      return { path: custom_copy_path };
+    }),
+  ];
+
+  const files_to_build = files_to_build_with_operation_and_platform?.filter((file) => {
+    return file?.operation === 'build_file';
+  });
+
+  for (let i = 0; i < files_to_copy?.length; i += 1) {
+    const file_to_copy = files_to_copy[i];
+    const stat = fs.lstatSync(file_to_copy?.path);
+
+    if (stat.isFile()) {
+      await mkdir(dirname(`${output_path}/${file_to_copy?.path}`), { recursive: true });
+      await copyFile(file_to_copy?.path, `${output_path}/${file_to_copy?.path}`);
+    }
+  }
+
+  await build_files({
+    files: files_to_build,
+    environment,
+    output_path,
+  }).catch((error) => {
+    console.warn(error);
+  });
+
+  if (build_type === "tar") {
+    const ignore_list = get_tar_ignore_list(settings?.config?.build?.excludedPaths);
+
+    await exec(
+      `cd ${output_path} && tar --exclude=${ignore_list} -czf ../build.tar.gz .`
+    );
+
+    await exec(`rm -rf ${output_path}`);
+  }
+
+  if (build_type === "tar" && options?.encrypt_build) {
+    const build_path = output_path?.replace('/.tar', '/build.tar.gz');
+
+    const encrypted_build = encrypt_buffer(
+      await readFile(build_path),
+      options?.encryption_key,
+    );
+
+    await writeFile(`.build/build.encrypted.tar.gz`, encrypted_build);
+  }
+
+  if (!options?.silence_confirmation) {
+    console.log(
+      chalk.greenBright(`\n✔ App built as ${build_type} to ${build_type === 'tar' ? output_path?.replace('/.tar', '/build.tar.gz') : output_path}!\n`)
+    );
+  }
+
+  if (await path_exists('.build/component_id_cache.json')) {
+    await exec(`rm -rf .build/component_id_cache.json`);
+  }
+};
+
+export default build;

package/src/lib/build/master_ignore_list.js

@@ -0,0 +1,14 @@
+const master_ignore_list = [
+  '.build',
+  '.DS_Store',
+  '.git',
+  '.joystick/build',
+  '.joystick/data',
+  '.push',
+  'node_modules',
+  'settings.development.json',
+  'settings.staging.json',
+  'settings.production.json',
+];
+
+export default master_ignore_list;

package/src/lib/build/minify_file.js

@@ -0,0 +1,22 @@
+import fs from "fs";
+import esbuild from "esbuild";
+import path_exists from "../path_exists.js";
+
+const { readFile, writeFile } = fs.promises;
+
+const minify_file = async (path = "") => {
+  if (await path_exists(path)) {
+    const file = await readFile(path, "utf-8");
+    const minified = await esbuild.transform(file, {
+      minify: true,
+    }).catch((error) => {
+      console.warn(error);
+    });
+
+    if (minified?.code) {
+      await writeFile(path, minified.code);
+    }
+  }
+};
+
+export default minify_file;

package/src/lib/build/node_paths.js

@@ -0,0 +1,19 @@
+import get_platform_safe_path from "./get_platform_safe_path.js";
+
+const node_paths = [
+  get_platform_safe_path("api/"),
+  get_platform_safe_path("caches/"),
+  get_platform_safe_path("cronJobs/"),
+  get_platform_safe_path("cron_jobs/"),
+  get_platform_safe_path("fixtures/"),
+  get_platform_safe_path("indexes/"),
+  get_platform_safe_path("lib/node"),
+  get_platform_safe_path("queues/"),
+  get_platform_safe_path("routes/"),
+  get_platform_safe_path("tests/"),
+  get_platform_safe_path("uploaders/"),
+  get_platform_safe_path("websockets/"),
+  "index.server.js",
+];
+
+export default node_paths;

package/src/lib/build/on_warn.js

@@ -0,0 +1,70 @@
+import chalk from "chalk";
+import constants from "../constants.js";
+import get_code_frame from "./get_code_frame.js";
+import rainbow_road from '../rainbow_road.js';
+
+const remove_location_data_from_stack_tree = (stack_trace = "") => {
+  return stack_trace.replace(constants.OBJECT_REGEX, "");
+};
+
+const log_error = (warning = {}) => {
+  const snippet_lines = warning?.snippet?.split(`\n`);
+
+  console.log('\n');
+  console.log(`${rainbow_road()}\n`);
+
+  if (warning.file) {
+    console.log(chalk.yellowBright(`Build Error in ${warning?.file}:\n`));
+  }
+
+  if (snippet_lines && snippet_lines.length > 0) {
+    snippet_lines.forEach((line) => {
+      if (line.includes(`> ${warning.line} |`)) {
+        return console.log(`   ${chalk.red(line)}`);
+      }
+
+      return console.log(`   ${chalk.gray(line)}`);
+    });
+  }
+
+  if (warning?.stack) {
+    console.log(chalk.magentaBright("\nStack Trace:\n"));
+    console.log(chalk.yellow(`   ${remove_location_data_from_stack_tree(warning?.stack)}\n`));
+  }
+
+  process.loader.error(
+    "Build error. Fix the error above to continue building your app."
+    );
+  console.log('\n');
+  console.log(`${rainbow_road()}\n`);
+};
+
+const parse_warning = async (warning = {}, type = "") => {
+  if (type && type === "BUILD_ERROR") {
+    return {
+      file: warning?.file,
+      snippet: warning?.snippet ? await get_code_frame(warning.file, {
+        line: warning?.line,
+        column: warning?.column,
+      }) : '',
+      stack: warning?.stack,
+      line: warning?.line,
+      character: warning?.column,
+      message: warning?.message,
+    };
+  }
+
+  return null;
+};
+
+const on_warn = async (warning) => {
+  const parsed_warning = await parse_warning(warning, "BUILD_ERROR");
+
+  if (parsed_warning) {
+    log_error(parsed_warning);
+  }
+
+  return parsed_warning;
+};
+
+export default on_warn;

package/src/lib/build/plugins/bootstrap_component.js

@@ -0,0 +1,191 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import get_platform_safe_path from '../../get_platform_safe_path.js';
+import constants from '../../constants.js';
+import set_component_id from './set_component_id.js';
+import path_exists from '../../path_exists.js';
+
+const { readFile, writeFile } = fs.promises;
+
+const restore_examples_without_mounting_code = (code = '', examples_before_replacement = []) => {
+	for (let i = 0; i < examples_before_replacement?.length; i += 1) {
+    const example_to_restore = examples_before_replacement[i];
+    code = code.replace(`%example:${i}%`, example_to_restore);
+  }
+};
+
+const add_page_mounting_code = (code = '', default_export = '', component_name = '') => {
+	return code.replace(
+    `${default_export};`,
+    `if (
+      typeof window !== 'undefined' &&
+      window.__joystick_should_auto_mount__ === true &&
+      !window.__joystick_layout_url__ &&
+      window.__joystick_page_url__ &&
+      !window.__joystick_hmr_update__ &&
+      joystick &&
+      joystick.mount
+    ) {
+      joystick.mount(${component_name}, window.__joystick_ssr_props__ || {}, document.getElementById('app'));
+    }
+
+    export default ${component_name};
+    `
+  );
+};
+
+const add_layout_mounting_code = (code = '', default_export = '', component_name = '') => {
+	return code.replace(
+	  `${default_export};`,
+	  `if (
+	    typeof window !== 'undefined' &&
+	    window.__joystick_should_auto_mount__ === true &&
+	    window.__joystick_layout_url__ &&
+      window.__joystick_page_url__ &&
+      !window.__joystick_hmr_update__ &&
+	    joystick &&
+	    joystick.mount
+	  ) {
+	    (async () => {
+	      const layout_component_file = await import(window.__joystick_layout_url__);
+	      const page_component_file = await import(window.window.__joystick_page_url__);
+	      const layout = layout_component_file.default;
+	      const page = page_component_file.default;
+	      joystick.mount(layout, Object.assign({ ...window.__joystick_ssr_props__ }, { page }), document.getElementById('app'));
+	    })();
+	  }
+
+	export default ${component_name};
+	  `
+	);
+};
+
+const replace_commented_code = (code = '') => {
+	return code.replace(constants.JOYSTICK_COMMENT_REGEX, "");
+};
+
+const set_placeholders_for_examples = (code = '') => {
+	// NOTE: Replace any <example> bracketed code with a placeholder. This ensures
+	// that we don't accidentally include any mounting code (or inject a _componentId)
+	// in Joystick example code included as content on the page.
+	//
+	// example_index is tracked to account for potential for multiple examples in a
+	// single file. example_index acts as a placeholder for the code to swap back
+  // in after the _componentId is set in restore_examples_without_mounting_code().
+  let example_index = 0;
+
+  return code.replace(
+    constants.EXAMPLE_CODE_REGEX,
+    () => {
+      return `%example:${example_index++}%`;
+    }
+  );
+};
+
+const get_examples_before_replacement = (code = '') => {
+	return code.match(constants.EXAMPLE_CODE_REGEX) || [];
+};
+
+const get_component_name = (default_export = null) => {
+  const default_export_parts = (default_export && default_export.split(" ")) || [];
+  return default_export_parts?.pop();
+};
+
+const check_if_valid_component_file = (has_joystick_ui = false, default_export = null) => {
+	return has_joystick_ui && !!default_export;
+};
+
+const get_default_export = (code = '') => {
+	const export_default_matches = code.match(constants.EXPORT_DEFAULT_REGEX) || [];
+	return export_default_matches && export_default_matches[0];
+};
+
+const check_if_has_joystick_ui = (code = '') => {
+  const joystick_ui_matches = code.match(constants.JOYSTICK_UI_REGEX) || [];
+	return !!joystick_ui_matches && !!joystick_ui_matches[0];
+};
+
+const check_if_is_component_type = (type ='', build_args = {}) => {
+  return [get_platform_safe_path(type)].some(
+    (bootstrap_target) => {
+      return build_args.path.includes(bootstrap_target);
+    }
+  );
+};
+
+const check_if_should_set_component_id = (entry_point = '') => {
+	return [
+    get_platform_safe_path("ui/"),
+    get_platform_safe_path("email/"),
+  ].some((bootstrap_target) => {
+    return entry_point.includes(bootstrap_target);
+  });
+};
+
+const bootstrap_component = (build = {}) => {
+  build.onLoad({ filter: /\.js$/ }, async (build_args = {}) => {
+    const is_layout_component = check_if_is_component_type('ui/layouts', build_args);
+    const is_page_component = check_if_is_component_type('ui/pages', build_args);      
+    const is_email_component = check_if_is_component_type('email/', build_args);
+    const is_component = is_layout_component || is_page_component || is_email_component;
+
+    if (is_component) {
+      let file_contents = await readFile(get_platform_safe_path(build_args.path), "utf-8");
+      
+      const has_joystick_ui = check_if_has_joystick_ui(file_contents);
+      const default_export = get_default_export(file_contents);
+      const is_valid_component_file = check_if_valid_component_file(has_joystick_ui, default_export);
+      const examples_before_replacement = get_examples_before_replacement(file_contents);
+      const component_name = get_component_name(default_export);
+
+      file_contents = set_placeholders_for_examples(file_contents);
+      file_contents = replace_commented_code(file_contents);
+      file_contents = component_name && is_layout_component ?
+        add_layout_mounting_code(file_contents, default_export, component_name) :
+        file_contents;
+      file_contents = component_name && is_page_component ?
+        add_page_mounting_code(file_contents, default_export, component_name) :
+        file_contents;
+
+      restore_examples_without_mounting_code(file_contents, examples_before_replacement);
+
+      return {
+        contents: file_contents,
+        loader: "js",
+      };
+    }
+  });
+
+  build.onEnd(() => {
+    return new Promise(async (resolve) => {
+      for (let i = 0; i < build?.initialOptions?.entryPoints?.length; i += 1) {
+        const entry_point = build?.initialOptions?.entryPoints[i];
+        const should_set_component_id = check_if_should_set_component_id(entry_point);
+        const build_exists = await path_exists(`${build?.initialOptions?.outdir}/${entry_point}`);
+
+        if (should_set_component_id && build_exists) {
+          let file_contents = await readFile(`${build?.initialOptions?.outdir}/${entry_point}`, "utf-8");
+          const has_joystick_ui = check_if_has_joystick_ui(file_contents);
+					const examples_before_replacement = get_examples_before_replacement(file_contents);
+          
+          file_contents = set_placeholders_for_examples(file_contents);
+
+          if (has_joystick_ui) {
+            file_contents = await set_component_id(file_contents);
+
+            for (let i = 0; i < examples_before_replacement?.length; i += 1) {
+              const example_to_restore = examples_before_replacement[i];
+              file_contents = file_contents.replace(`%example:${i}%`, example_to_restore);
+            }
+            
+            await writeFile(`${build?.initialOptions?.outdir}/${entry_point}`, file_contents);
+          }
+        }
+      }
+
+      resolve();
+    });
+  });
+};
+
+export default bootstrap_component;

package/src/lib/build/plugins/generate_file_dependency_map.js

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import get_platform_safe_path from '../../get_platform_safe_path.js';
+import update_file_map from './update_file_map.js';
+
+const { readFile } = fs.promises;
+
+const generate_file_dependency_map = (build = {}) => {
+  build.onLoad({ filter: /\.js$/ }, async (args) => {
+    const can_add_to_map = !["node_modules", ".joystick", "?", "commonjsHelpers.js"].some((excluded_path) => {
+      return get_platform_safe_path(args.path).includes(excluded_path);
+    });
+
+    if (can_add_to_map) {
+      const code = await readFile(get_platform_safe_path(args.path), "utf-8");
+      await update_file_map(get_platform_safe_path(args.path), code);
+    }
+  });
+};
+
+export default generate_file_dependency_map;

package/src/lib/build/plugins/index.js

@@ -0,0 +1,26 @@
+import bootstrap_component from './bootstrap_component.js';
+import generate_file_dependency_map from './generate_file_dependency_map.js';
+import warn_node_environment from "./warn_node_environment.js";
+
+const plugins = {
+  bootstrap_component: {
+    name: "bootstrap_component",
+    setup(build) {
+    	bootstrap_component(build);
+    },
+  },
+  generate_file_dependency_map: {
+    name: "generate_file_dependency_map",
+    setup(build) {
+    	generate_file_dependency_map(build);
+    },
+  },
+  warn_node_environment: {
+    name: "warn_node_environment",
+    setup(build) {
+      warn_node_environment(build);
+    },
+  },
+};
+
+export default plugins;

package/src/lib/build/plugins/set_component_id.js

@@ -0,0 +1,89 @@
+import fs from "fs";
+import generate_id from "../../generate_id.js";
+import path_exists from "../../path_exists.js";
+
+const { readFile, writeFile } = fs.promises;
+
+const update_component_id_cache = async (component_id_targets = [], component_id_cache = {}, component_id_cache_path = '') => {
+  for (let i = 0; i < component_id_targets.length; i += 1) {
+    const component = component_id_targets[i];
+    component_id_cache[component.path] = component.component_id;
+    await writeFile(component_id_cache_path, JSON.stringify(component_id_cache));
+  }
+};
+
+const inject_component_id = (component_id_targets = [], file = '') => {
+  let updated_file = file;
+
+  for (let i = 0; i < component_id_targets.length; i += 1) {
+    const component = component_id_targets[i];
+
+    const tainted = component.source.replace(
+      /\.component\(\{+(?!\n + _componentId)/g,
+      () => {
+        return `.component({\n  _componentId: '${component.component_id}',`;
+      }
+    );
+
+    updated_file = updated_file.replace(component.source, tainted);
+  }
+
+  return updated_file;
+};
+
+const get_component_id_targets = (file = '', component_paths_from_esbuild_output = [], component_id_cache = {}) => {
+  return component_paths_from_esbuild_output?.map((component_path, component_path_index) => {
+    const next_component_path = component_paths_from_esbuild_output[component_path_index + 1];
+    const path_without_comment = component_path.path.replace("// ", "");
+
+    return {
+      path: path_without_comment,
+      component_id: component_id_cache[path_without_comment] || generate_id(16),
+      index: component_path.index,
+      source: file.substring(
+        component_path.index,
+        next_component_path ? next_component_path.index : file.length
+      ),
+    };
+  });
+};
+
+const get_component_paths_from_esbuild_output = (file = '') => {
+  return [...file?.matchAll(/\/\/ ui+.*/gi), ...file?.matchAll(/\/\/ email+.*/gi)]?.map((match) => {
+    return {
+      path: match[0],
+      index: match.index,
+    };
+  });
+};
+
+const get_existing_component_id_cache = async (component_id_cache_path = '') => {
+  const has_component_id_cache = await path_exists(component_id_cache_path);
+
+  if (has_component_id_cache) {
+    const component_id_cache = await readFile(component_id_cache_path, 'utf-8');
+    return JSON.parse(component_id_cache);
+  }
+
+  return {};
+};
+
+const get_component_id_cache_path = () => {
+  return ['development', 'test'].includes(process.env.NODE_ENV)
+    ? `./.joystick/build/component_id_cache.json`
+    : `./.build/component_id_cache.json`;
+};
+
+const set_component_id = async (file = "") => {
+  const component_id_cache_path = get_component_id_cache_path();
+  const component_id_cache = await get_existing_component_id_cache(component_id_cache_path);
+  const component_paths_from_esbuild_output = get_component_paths_from_esbuild_output(file);
+  const component_id_targets = get_component_id_targets(file, component_paths_from_esbuild_output, component_id_cache);
+
+  const file_with_component_id = inject_component_id(component_id_targets, file);
+  await update_component_id_cache(component_id_targets, component_id_cache, component_id_cache_path);
+
+  return file_with_component_id;
+};
+
+export default set_component_id;

package/src/lib/build/plugins/update_file_map.js

@@ -0,0 +1,98 @@
+import fs from "fs";
+import path, { dirname } from 'path';
+import * as acorn from "acorn";
+import path_exists from '../../path_exists.js';
+
+const { readFile, writeFile } = fs.promises;
+
+const get_requires = (from_path = '', map = {}) => {
+  const requires = map?.body?.filter((statement) => {
+    const type = statement && statement.type;
+    const declarations = (statement && statement.declarations) || [];
+
+    const is_variable_declaration = type === "VariableDeclaration";
+
+    const has_require_statement = declarations.some((declaration) => {
+      const is_variable_declarator = declaration.type === "VariableDeclarator";
+      const callee_name = declaration?.init?.callee?.name;
+      return is_variable_declarator && callee_name === "require";
+    });
+
+    return is_variable_declaration && has_require_statement;
+  });
+
+  return requires.map((require_declaration) => {
+    const declarations = require_declaration.declarations;
+    const declaration = declarations && declarations[0];
+    const declaration_value = declaration?.init?.arguments[0] && declaration.init.arguments[0]?.value;
+
+    return {
+      absolute_path: declaration_value ? path.resolve(dirname(from_path), declaration_value) : null,
+    };
+  });
+};
+
+const get_imports = (from_path = '', map = {}) => {
+  const imports = map?.body?.filter(({ type }) => {
+    return type === "ImportDeclaration";
+  }) || [];
+
+  return imports.map((import_declaration) => {
+    return {
+      path: import_declaration?.source?.value,
+      absolute_path: path.resolve(dirname(from_path), import_declaration?.source?.value),
+    };
+  });
+};
+
+const get_imports_and_requires = (from_path = '', map = {}) => {
+  const imports = get_imports(from_path, map);
+  const requires = get_requires(from_path, map);
+
+  return {
+    imports,
+    requires,
+  };
+};
+
+const parse_file_to_ast = (file = "") => {
+  return acorn.parse(file, {
+    ecmaVersion: "latest",
+    sourceType: "module",
+  });
+};
+
+const read_file_dependency_map = async () => {
+  const file_dependency_map_path = `.joystick/build/file_map.json`;
+
+  if (await path_exists(file_dependency_map_path)) {
+    const file_dependency_map_as_json = fs.readFileSync(
+      file_dependency_map_path,
+      "utf-8"
+    );
+
+    return file_dependency_map_as_json ? JSON.parse(file_dependency_map_as_json) : {};
+  }
+
+  return {};
+};
+
+const update_file_map = async (from_path = "", source = "") => {
+  try {
+    const file_dependency_map = await read_file_dependency_map();
+    const file_ast = parse_file_to_ast(source);
+    const imports = file_ast ? get_imports_and_requires(from_path, file_ast) : [];
+
+    file_dependency_map[from_path] = imports;
+
+    fs.writeFileSync(
+      `.joystick/build/file_map.json`,
+      JSON.stringify(file_dependency_map, null, 2)
+    );
+  } catch {
+    // Do nothing. This exists to handle acorn parsing errors that are also picked
+    // up by the esbuild parser (we want to defer to esbuild).
+  }
+};
+
+export default update_file_map;