feat: enable useOwnWorker for custom provider

Author: jotanarciso

lib/build/dispatcher/dispatcher.js

@@ -49,9 +49,10 @@ async function getAliasPath(alias) {
  * @param {string} preset - The build preset.
  * @param {string} entry - The entrypoint file path.
  * @param {string} mode - The mode of preset build.
- * @returns {any} The context that will be used in build.
+ * @param {boolean} useOwnWorker - The mode of preset build.
+ * @returns {any} This flag indicates that the constructed code inserts its own worker (provider) expression.
  */
-async function loadBuildContext(preset, entry, mode) {
+async function loadBuildContext(preset, entry, mode, useOwnWorker) {
   const VALID_BUILD_PRESETS = presets.getKeys();
 
   const validPreset = VALID_BUILD_PRESETS.includes(preset);
@@ -97,16 +98,21 @@ async function loadBuildContext(preset, entry, mode) {
   prebuildFilePath = new URL(`file://${prebuildFilePath}`).href;
 
   const config = (await import(configFilePath)).default;
-  const { useOwnWorker } = config;
 
   const prebuild = (await import(prebuildFilePath)).default;
-
   const handlerTemplate = readFileSync(handlerFilePath, 'utf-8');
   const handlerTemplateBody = getExportedFunctionBody(handlerTemplate);
 
   let newEntryContent;
+
+  // use providers
+  if (useOwnWorker) {
+    newEntryContent = `(async function() {
+      ${handlerTemplateBody}
+    })()`;
+  }
+
   if (!useOwnWorker) {
-    // use default provider
     const workerFilePath = join(
       vulcanLibPath,
       'providers',
@@ -122,11 +128,6 @@ async function loadBuildContext(preset, entry, mode) {
       })()`,
     );
   }
-  if (useOwnWorker) {
-    newEntryContent = `(async function() {
-      ${handlerTemplateBody}
-    })()`;
-  }
 
   // resolve #edge alias without vulcan context
   const edgehooksPath = await getAliasPath('edge');
@@ -139,11 +140,18 @@ async function loadBuildContext(preset, entry, mode) {
     try {
       const filePath = join(process.cwd(), entry);
       const entryContent = readFileSync(filePath, 'utf-8');
-      const entrypointModified = getExportedFunctionBody(entryContent);
-      newEntryContent = newEntryContent.replace(
-        '__JS_CODE__',
-        entrypointModified,
-      );
+
+      if (useOwnWorker) {
+        newEntryContent = newEntryContent.replace('__JS_CODE__', entryContent);
+        console.log(newEntryContent);
+      }
+      if (!useOwnWorker) {
+        const entrypointModified = getExportedFunctionBody(entryContent);
+        newEntryContent = newEntryContent.replace(
+          '__JS_CODE__',
+          entrypointModified,
+        );
+      }
     } catch (error) {
       feedback.build.error(Messages.errors.file_doesnt_exist(entry));
       debug.error(error);
@@ -208,12 +216,15 @@ class Dispatcher {
    * @param {string} mode - The mode of build target.
    * @param {string} entry - The entry point for the build.
    * @param {boolean} useNodePolyfills - The flag to indicates polyfills use.
+   * @param {boolean} useOwnWorker - This flag indicates that the constructed code inserts its own worker expression,
+   * such as addEventListener("fetch") or similar, without the need to inject a provider.
    */
-  constructor(preset, mode, entry, useNodePolyfills) {
+  constructor(preset, mode, entry, useNodePolyfills, useOwnWorker) {
     this.preset = preset;
     this.mode = mode;
     this.entry = entry;
     this.useNodePolyfills = useNodePolyfills;
+    this.useOwnWorker = useOwnWorker;
     this.buildId = generateTimestamp();
   }
 
@@ -230,11 +241,13 @@ class Dispatcher {
       );
       process.exit(1);
     }
+
     // Load Context based on preset
     const { entryContent, prebuild, config } = await loadBuildContext(
       this.preset,
       this.entry,
       this.mode,
+      this.useOwnWorker,
     );
 
     const buildContext = {
@@ -244,6 +257,7 @@ class Dispatcher {
       entryContent,
       config,
       useNodePolyfills: this.useNodePolyfills,
+      useOwnWorker: this.useOwnWorker,
       buildId: this.buildId,
     };
 
@@ -267,6 +281,7 @@ class Dispatcher {
       config.entry = tempBuilderEntryPath;
       config.buildId = this.buildId;
       config.useNodePolyfills = this.useNodePolyfills;
+      config.useOwnWorker = this.useOwnWorker;
 
       let builder;
       switch (config.builder) {
@@ -292,7 +307,12 @@ class Dispatcher {
           entry: this.entry,
           preset: this.preset,
           mode: this.mode,
-          useNodePolyfills: this.useNodePolyfills,
+          ...(this.useNodePolyfills !== null && {
+            useNodePolyfills: this.useNodePolyfills,
+          }),
+          ...(this.useOwnWorker !== null && {
+            useOwnWorker: this.useOwnWorker,
+          }),
         },
         'local',
       );

lib/commands/build.commands.js

@@ -14,6 +14,7 @@ import { vulcan } from '#env';
  * @param {string} [options.preset] - Preset to be used (e.g., 'javascript', 'typescript').
  * @param {string} [options.mode] - Mode in which to run the build (e.g., 'deliver', 'compute').
  * @param {boolean} [options.useNodePolyfills] - Whether to use Node.js polyfills.
+ * @param {boolean} [options.useOwnWorker] - This flag indicates that the constructed code inserts its own worker expression, such as addEventListener("fetch") or similar, without the need to inject a provider.
  * @returns {Promise<void>} - A promise that resolves when the build is complete.
  * @example
  *
@@ -24,12 +25,19 @@ import { vulcan } from '#env';
  *   useNodePolyfills: false
  * });
  */
-async function buildCommand({ entry, preset, mode, useNodePolyfills }) {
+async function buildCommand({
+  entry,
+  preset,
+  mode,
+  useNodePolyfills,
+  useOwnWorker,
+}) {
   let config = {
     entry,
     preset,
     mode,
     useNodePolyfills,
+    useOwnWorker,
   };
 
   const vulcanVariables = await vulcan.readVulcanEnv('local');
@@ -40,7 +48,8 @@ async function buildCommand({ entry, preset, mode, useNodePolyfills }) {
     preset: preset ?? vulcanVariables?.preset ?? 'javascript',
     mode: mode ?? vulcanVariables?.mode ?? 'compute',
     useNodePolyfills:
-      useNodePolyfills ?? vulcanVariables?.useNodePolyfills ?? false,
+      useNodePolyfills ?? vulcanVariables?.useNodePolyfills ?? null,
+    useOwnWorker: useOwnWorker ?? vulcanVariables?.useOwnWorker ?? null,
   };
   feedback.info(`Using ${config.entry} as entry point by default`);
 
@@ -50,6 +59,7 @@ async function buildCommand({ entry, preset, mode, useNodePolyfills }) {
     config.mode,
     config.entry,
     config.useNodePolyfills,
+    config.useOwnWorker,
   );
 
   await buildDispatcher.run();

lib/main.js

@@ -82,6 +82,10 @@ function startVulcanProgram() {
     )
     .option('--mode <type>', 'Mode of build target (e.g., deliver, compute)')
     .option('--useNodePolyfills', 'Use node polyfills in build.')
+    .option(
+      '--useOwnWorker',
+      'This flag indicates that the constructed code inserts its own worker expression, such as addEventListener("fetch") or similar, without the need to inject a provider.',
+    )
     .option(
       '--useOwnWorker',
       'Enabling this setting disables the automatic insertion of \'addEventListener("fetch")\' or equivalent for each provider.',