@joystick.js/cli-canary 0.0.0-canary.67 → 0.0.0-canary.670

package/src/lib/build/build_files.js

@@ -0,0 +1,161 @@
+import esbuild from "esbuild";
+import svg from "esbuild-plugin-svg";
+import build_plugins from "./plugins/index.js";
+import get_code_frame from "./get_code_frame.js";
+import minify_file from "../build/minify_file.js";
+import on_warn from "./on_warn.js";
+import path_exists from '../path_exists.js';
+
+const handle_build_exception = async (exception = {}, file = '') => {
+  const error = exception?.errors && exception?.errors[0];
+  const snippet = await path_exists(file) ? await get_code_frame(file, {
+    line: error?.location?.line,
+    column: error?.location?.column,
+  }) : null;
+
+  await on_warn({
+    file,
+    stack: exception?.stack,
+    line: error?.location?.line,
+    column: error?.location?.column,
+    snippet,
+    lineWithError: error?.location?.lineText?.trim(),
+    message: error?.text,
+  });
+
+  return snippet;
+};
+
+const handle_parse_file_path_from_exception = (exception = {}) => {
+  const raw_error_message = exception?.message?.split(':');
+
+  // NOTE: If the build error pertains to a file that esbuild CANNOT build, the
+  // structure of the error is slightly different, placing the file(s) w/ errors
+  // after the string "files:" (which lands at index 3 in the split array).
+  if (raw_error_message[2] && raw_error_message[2]?.includes('No loader')) {
+    return raw_error_message[3] && raw_error_message[3]?.replace('\n', '') || '';
+  }
+
+  // NOTE: IF the build error is just a syntax error, the offending file will be
+  // palced at index 1.
+  return raw_error_message[1] && raw_error_message[1]?.replace('\n', '') || '';
+};
+
+const handle_build_failure = async (exception = {}) => {
+  const file = handle_parse_file_path_from_exception(exception);
+  const snippet = await handle_build_exception(exception, file);
+  
+  return {
+    success: false,
+    path: file,
+    error: {
+      stack: exception?.stack,
+      snippet,
+    },
+  };
+};
+
+const handle_build_for_node = (node_paths = [], options = {}) => {
+  return esbuild.build({
+    allowOverwrite: true,
+    platform: "node",
+    format: "esm",
+    bundle: false,
+    entryPoints: node_paths?.map((file) => file.path),
+    entryNames: '[dir]/[name]',
+    outdir: options?.output_path || "./.joystick/build",
+    outbase: './',
+    define: {
+      "process.env.NODE_ENV": `'${options?.environment || 'development'}'`,
+    },
+    logLevel: "silent",
+    plugins: [
+      build_plugins.warn_node_environment,
+      build_plugins.generate_file_dependency_map
+    ],
+  });
+};
+
+const handle_build_for_browser = (browser_paths = [], options = {}) => {
+  return esbuild.build({
+    allowOverwrite: true,
+    target: "es2020",
+    platform: "browser",
+    format: "esm",
+    bundle: true,
+    entryPoints: browser_paths?.map((file) => file.path),
+    entryNames: '[dir]/[name]',
+    outbase: './',
+    outdir: options?.output_path || "./.joystick/build",
+    define: {
+      "process.env.NODE_ENV": `'${options?.environment || 'development'}'`,
+    },
+    logLevel: 'silent',
+    loader: {
+      '.svg': 'text',
+    },
+    plugins: [
+      build_plugins.warn_node_environment,
+      build_plugins.generate_file_dependency_map,
+      build_plugins.bootstrap_component,
+      svg(),
+    ]
+  });
+};
+
+const build_files = async (options) => {
+  const dirty_files = ['.DS_Store'];
+  
+  const node_files = options?.files?.filter((file) => {
+    return !dirty_files?.some((dirty_file) => {
+      return file?.path?.includes(dirty_file);
+    });
+  })?.filter((file) => file?.platform === 'node');
+
+  const browser_files = options?.files?.filter((file) => {
+    return !dirty_files?.some((dirty_file) => {
+      return file?.path?.includes(dirty_file);
+    });
+  })?.filter((file) => file?.platform === 'browser');
+  
+  let node_file_results = [];
+  let browser_file_results = [];
+
+  if (node_files?.length > 0) {
+    node_file_results = [await handle_build_for_node(node_files, options)
+      .then(() => {
+        return { success: true };
+      }).catch((exception) => handle_build_failure(exception))];
+  }
+
+  if (browser_files?.length > 0) {
+    browser_file_results = [await handle_build_for_browser(browser_files, options)
+      .then(() => {
+        return { success: true };
+      }).catch((exception) => handle_build_failure(exception))];
+  }
+
+  const node_files_have_errors = node_file_results?.some((node_file_result) => !node_file_result?.success);
+  const browser_files_have_errors = browser_file_results?.some((browser_file_result) => !browser_file_result?.success);
+
+  if (node_files_have_errors || browser_files_have_errors) {
+    return Promise.reject([
+      ...node_file_results,
+      ...browser_file_results,
+    ]);
+  }
+  
+  if (process.env.NODE_ENV !== 'development') {
+    await Promise.all([...browser_files, ...node_files].map((file) => {
+      return minify_file(`${options?.output_path || "./.joystick/build"}/${file.path}`);
+    })); 
+  }
+  
+  return [
+    ...node_file_results,
+    ...browser_file_results,
+  ];
+};
+
+export default build_files;
+

package/src/{functions/start/filesToCopy.js → lib/build/copy_paths.js}

@@ -1,8 +1,8 @@
-export default [
-  { path: "css", regex: new RegExp(/^css\//) },
-  { path: "i18n", regex: new RegExp(/^i18n\//) },
-  { path: "public", regex: new RegExp(/^public\//) },
-  { path: "private", regex: new RegExp(/^private\//) },
+const copy_paths = [
+  { path: "css", regex: new RegExp(process.platform === 'win32' ? /^css\\/ : /^css\//) },
+  { path: "i18n", regex: new RegExp(process.platform === 'win32' ? /^i18n\\/ : /^i18n\//) },
+  { path: "public", regex: new RegExp(process.platform === 'win32' ? /^public\\/ : /^public\//) },
+  { path: "private", regex: new RegExp(process.platform === 'win32' ? /^private\\/ : /^private\//) },
   { path: "index.html", regex: new RegExp(/^index.html/) },
   { path: "index.css", regex: new RegExp(/^index.css/) },
   { path: "package.json", regex: new RegExp(/^package.json/) },
@@ -13,3 +13,5 @@ export default [
   { path: "settings.production.json", regex: new RegExp(/^settings.production.json/) },
   { path: ".html", regex: new RegExp(/^([0-9a-zA-Z-._])+.html/) },
 ];
+
+export default copy_paths;

package/src/lib/build/get_code_frame.js

@@ -0,0 +1,11 @@
+import fs from 'fs';
+import { codeFrameColumns } from "@babel/code-frame";
+
+const { readFile } = fs.promises;
+
+const get_code_frame = async (path = "", location = {}) => {
+  const file = await readFile(path, "utf-8");
+  return codeFrameColumns(file, { start: location });
+};
+
+export default get_code_frame;

package/src/lib/build/get_file_operation.js

@@ -0,0 +1,25 @@
+import copy_paths from "./copy_paths.js";
+
+const check_if_is_copy_path = (path = '') => {
+  return copy_paths.some((file_to_copy) => {
+    return file_to_copy.regex.test(path);
+  });
+};
+
+const check_if_is_javascript = (file_extension = '') => {
+	return file_extension === 'js';
+};
+
+const get_file_operation = (path = '') => {
+	const file_extension = path?.split('.')?.pop();
+	const is_javascript = check_if_is_javascript(file_extension);
+	const is_copy_path = check_if_is_copy_path(path);
+
+	if (!is_javascript || (is_javascript && is_copy_path)) {
+		return 'copy_file';
+	}
+
+	return 'build_file';
+};
+
+export default get_file_operation;

package/src/lib/build/get_files_to_build.js

@@ -0,0 +1,36 @@
+import fs from "fs";
+import get_files_in_path from "../get_files_in_path.js";
+import master_ignore_list from "./master_ignore_list.js";
+
+const { stat } = fs.promises;
+
+const get_files_to_build = async (excluded_paths = [], context = null) => {
+  const files = await get_files_in_path("./", []);
+
+  const master_ignore_list_filtered_for_context = context && context === 'start' ? master_ignore_list?.filter((file_to_ignore) => {
+    return !file_to_ignore.includes('settings');
+  }) : master_ignore_list;
+
+  const filtered_files = files
+    .filter((path) => {
+      const is_excluded = excluded_paths.some((excluded_path) => {
+        return path.includes(excluded_path);
+      });
+
+      return !is_excluded;
+    })
+    .filter((path) => {
+      const is_excluded = master_ignore_list_filtered_for_context.some((excluded_path) => {
+        return path.includes(excluded_path);
+      });
+
+      return !is_excluded;
+    })
+    .filter((path) => {
+      return !fs.lstatSync(path).isDirectory();
+    });
+
+  return filtered_files;
+};
+
+export default get_files_to_build;

package/src/lib/build/get_path_platform.js

@@ -0,0 +1,32 @@
+import browser_path_exclusions from "./browser_path_exclusions.js";
+import browser_paths from "./browser_paths.js";
+import node_paths from "./node_paths.js";
+
+const check_if_node_path = (path = '') => {
+	return node_paths.some((node_path) => {
+    return path.includes(node_path);
+  });
+};
+
+const check_if_browser_path = (path = '') => {
+  return browser_paths.some((browser_path) => {
+    return path.includes(browser_path);
+  }) && !browser_path_exclusions.some((browser_path_exclusion) => {
+    return path.includes(browser_path_exclusion);
+  });
+};
+
+const get_path_platform = (path = '') => {
+	const is_browser_path = check_if_browser_path(path);
+	const is_node_path = check_if_node_path(path);
+
+	if (is_browser_path) {
+		return 'browser';
+	}
+
+	if (is_node_path) {
+		return 'node';
+	}
+};
+
+export default get_path_platform;

package/src/lib/build/get_platform_safe_path.js

@@ -0,0 +1,6 @@
+const get_platform_safe_path = (path = '') => {
+  // NOTE: This is why serial killers exist.
+  return process.platform === 'win32' ? path.replace('/', '\\') : path;
+};
+
+export default get_platform_safe_path;

package/src/lib/build/get_tar_ignore_list.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import master_ignore_list from "./master_ignore_list.js";
+
+const get_tar_ignore_list = (excluded_paths = []) => {
+  const git_ignore = fs.existsSync(".gitignore")
+    ? fs.readFileSync(".gitignore", "utf-8")
+    : "";
+    
+  const git_ignore_files = git_ignore?.split("\n")?.filter((file) => {
+    return !file?.includes("#") && file?.trim() !== "";
+  });
+
+  // NOTE: The ^ character is an anchor to tell tar to only match the pattern
+  // to the root path. Without this, it will match all nested paths that resemble
+  // the pattern you give it. For example, ./versions will match the api/versions
+  // directory too.
+  const files_to_ignore = [
+    ...(git_ignore_files || [])?.map((ignore) => {
+      return `^${ignore}`;
+    }),
+    ...(excluded_paths || [])?.map((ignore) => {
+      return `^${ignore}`;
+    }),
+    ...(master_ignore_list || [])?.map((ignore) => {
+      return `^${ignore}`;
+    }),
+    "*.tar",
+    "*.tar.gz",
+    "*.tar.xz",
+  ]?.filter((item, itemIndex, array) => {
+    return array.indexOf(item) === itemIndex;
+  });
+
+  const exclude_list = `{${files_to_ignore
+    ?.map((file_to_ignore) => `"${file_to_ignore}"`)
+    .join(",")}}`;
+
+  return exclude_list;
+};
+
+export default get_tar_ignore_list;

package/src/lib/build/index.js

@@ -0,0 +1,101 @@
+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 } = fs.promises;
+const exec = util.promisify(child_process.exec);
+
+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 files_for_build = await get_files_to_build(excluded_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';
+  })
+
+  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];
+    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,15 @@
+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 });
+    await writeFile(path, minified.code);
+  }
+};
+
+export default minify_file;

package/src/lib/build/node_paths.js

@@ -0,0 +1,17 @@
+import get_platform_safe_path from "./get_platform_safe_path.js";
+
+const node_paths = [
+  get_platform_safe_path("api/"),
+  get_platform_safe_path("cronJobs/"),
+  get_platform_safe_path("cron_jobs/"),
+  get_platform_safe_path("fixtures/"),
+  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;