@wix/astro 1.0.23 → 1.0.25

package/src/index.ts

@@ -4,36 +4,34 @@ import type { AstroConfig, AstroIntegration } from 'astro';
 import { envField, passthroughImageService } from 'astro/config';
 import chokidar from 'chokidar';
 import { outdent } from 'outdent';
-import type { Model } from './types.js';
 import { EXTENSIONS_DIR, GIT_IGNORED_DIR } from './directories.js';
 import { patchAstroInlineScripts } from './plugins/patchAstroInlineScripts.js';
 import { patchGlobal } from './plugins/patchGlobal.js';
 import { setupSsrContext } from './plugins/setupSsrContext.js';
+import { buildComponents } from './utils/buildComponents.js';
 import { createProjectModel } from './utils/createProjectModel.js';
-import { outputDir, writeJson } from './utils/fs-utils.js';
+import { clearDir, writeJson } from './utils/fs-utils.js';
 import { generateAppManifest } from './utils/generateAppManifest.js';
-import { isValidBackofficeComponent } from './utils/isValidBackofficeComponent.js';
-import { isValidServicePluginComponent } from './utils/isValidServicePluginComponent.js';
-import { isValidWebhookComponent } from './utils/isValidWebhookComponent.js';
+import { removeUnusedCodegenFiles } from './utils/removeUnusedCodegenFiles.js';
 import { resolveBuildMetadata } from './utils/resolveBuildMetadata.js';
-import { writeVirtualBackofficeExtensionFiles } from './utils/writeVirtualBackofficeExtensionFiles.js';
-import { writeVirtualServicePluginExtensionFiles } from './utils/writeVirtualServicePluginExtensionFiles.js';
-import { writeVirtualWebhookExtensionFiles } from './utils/writeVirtualWebhookExtensionFiles.js';
+
+interface WixIntegrationOptions {
+  enableAuthRoutes?: boolean;
+  enableHtmlEmbeds?: boolean;
+}
 
 const createIntegration = (
-  options: {
-    enableAuthRoutes?: boolean;
-  } = {
+  options: WixIntegrationOptions = {
     enableAuthRoutes: true,
+    enableHtmlEmbeds: true,
   }
 ): AstroIntegration => {
   let _config: AstroConfig;
-  let model: Model | null = null;
 
   return {
     hooks: {
       async 'astro:build:done'({ logger }) {
-        model ??= await createProjectModel(logger);
+        const model = await createProjectModel(logger);
         const appManifest = generateAppManifest(model);
 
         const outDir = fileURLToPath(_config.outDir);
@@ -62,11 +60,14 @@ const createIntegration = (
         logger,
         updateConfig,
       }) {
+        const isDev = command === 'dev';
+
         const codegenDirURL = createCodegenDir();
         const codegenDir = fileURLToPath(codegenDirURL);
         const rootDir = fileURLToPath(config.root);
+        const extensionsDir = join(codegenDir, 'extensions');
 
-        model ??= await createProjectModel(logger);
+        const model = await createProjectModel(logger);
 
         // support client-side context calls
         injectScript(
@@ -89,15 +90,6 @@ const createIntegration = (
           `
         );
 
-        // inject HTML embeds
-        addMiddleware({
-          entrypoint: new URL(
-            '../build-runtime/middleware/html-embeds.js',
-            import.meta.url
-          ),
-          order: 'post',
-        });
-
         // support server side context calls
         addMiddleware({
           entrypoint: new URL(
@@ -107,40 +99,18 @@ const createIntegration = (
           order: 'pre',
         });
 
-        updateConfig({
-          env: {
-            schema: {
-              WIX_CLIENT_ID: envField.string({
-                access: 'public',
-                context: 'client',
-              }),
-              WIX_CLIENT_INSTANCE_ID: envField.string({
-                access: 'secret',
-                context: 'server',
-              }),
-              WIX_CLIENT_PUBLIC_KEY: envField.string({
-                access: 'secret',
-                context: 'server',
-              }),
-              WIX_CLIENT_SECRET: envField.string({
-                access: 'secret',
-                context: 'server',
-              }),
-            },
-          },
-          image: {
-            domains: ['static.wixstatic.com'],
-            service: passthroughImageService(),
-          },
-          vite: {
-            plugins: [
-              patchGlobal(),
-              patchAstroInlineScripts(),
-              setupSsrContext(rootDir),
-            ],
-          },
-        });
+        // support HTML embeds
+        if (options.enableHtmlEmbeds) {
+          addMiddleware({
+            entrypoint: new URL(
+              '../build-runtime/middleware/html-embeds.js',
+              import.meta.url
+            ),
+            order: 'post',
+          });
+        }
 
+        // support auth routes
         if (options.enableAuthRoutes) {
           injectRoute({
             entrypoint: new URL(
@@ -179,60 +149,63 @@ const createIntegration = (
           });
         }
 
-        // add support for webhook extensions
-        const webhookCodegenDir = join(codegenDir, 'extensions/webhooks');
-        await outputDir(webhookCodegenDir);
+        updateConfig({
+          env: {
+            schema: {
+              WIX_CLIENT_ID: envField.string({
+                access: 'public',
+                context: 'client',
+              }),
+              WIX_CLIENT_INSTANCE_ID: envField.string({
+                access: 'secret',
+                context: 'server',
+              }),
+              WIX_CLIENT_PUBLIC_KEY: envField.string({
+                access: 'secret',
+                context: 'server',
+              }),
+              WIX_CLIENT_SECRET: envField.string({
+                access: 'secret',
+                context: 'server',
+              }),
+            },
+          },
+          image: {
+            domains: ['static.wixstatic.com'],
+            service: passthroughImageService(),
+          },
+          vite: {
+            plugins: [
+              patchGlobal(),
+              patchAstroInlineScripts(),
+              setupSsrContext(rootDir),
+            ],
+          },
+        });
+
+        // build relevant wix extensions
+        await clearDir(codegenDir);
+        await buildComponents({ extensionsDir, injectRoute, isDev, model });
+
+        if (isDev) {
+          injectRoute({
+            entrypoint: new URL('../runtime/entry.astro', import.meta.url),
+            pattern: `/_wix/extensions/backoffice/[compId]`,
+            prerender: false,
+          });
 
-        if (command === 'dev') {
           injectRoute({
             entrypoint: new URL(
-              '../build-runtime/routes/webhooks.js',
+              '../build-runtime/routes/webhooksDevRoute.js',
               import.meta.url
             ),
             pattern: `/_wix/extensions/webhooks/[compId]`,
             prerender: false,
           });
 
-          chokidar
-            .watch([EXTENSIONS_DIR], {
-              cwd: rootDir,
-              ignoreInitial: true,
-              useFsEvents: false,
-            })
-            .on('all', async () => {
-              model = await createProjectModel(logger);
-              await writeVirtualWebhookExtensionFiles(model, webhookCodegenDir);
-            });
-        } else {
-          const webhookComponents = model.components.filter(
-            isValidWebhookComponent
-          );
-          for (const component of webhookComponents) {
-            const virtualEntrypoint = join(
-              webhookCodegenDir,
-              `${component.manifest.compId}.ts`
-            );
-
-            injectRoute({
-              entrypoint: virtualEntrypoint,
-              pattern: `/_wix/extensions/webhooks/${component.manifest.compId}`,
-            });
-          }
-        }
-
-        await writeVirtualWebhookExtensionFiles(model, webhookCodegenDir);
-
-        // add support for service plugin extensions
-        const servicePluginCodegenDir = join(
-          codegenDir,
-          'extensions/service-plugins'
-        );
-        await outputDir(servicePluginCodegenDir);
-
-        if (command === 'dev') {
           injectRoute({
             entrypoint: new URL(
-              '../build-runtime/routes/service-plugins.js',
+              '../build-runtime/routes/servicePluginsDevRoute.js',
               import.meta.url
             ),
             pattern: `/_wix/extensions/service-plugins/[compId]`,
@@ -246,76 +219,18 @@ const createIntegration = (
               useFsEvents: false,
             })
             .on('all', async () => {
-              model = await createProjectModel(logger);
-              await writeVirtualServicePluginExtensionFiles(
-                model,
-                servicePluginCodegenDir
-              );
-            });
-        } else {
-          const servicePluginComponents = model.components.filter(
-            isValidServicePluginComponent
-          );
-          for (const component of servicePluginComponents) {
-            const virtualEntrypoint = join(
-              servicePluginCodegenDir,
-              `${component.manifest.compId}.ts`
-            );
-            injectRoute({
-              entrypoint: virtualEntrypoint,
-              pattern: `/_wix/extensions/service-plugins/${component.manifest.compId}`,
-            });
-          }
-        }
-
-        await writeVirtualServicePluginExtensionFiles(
-          model,
-          servicePluginCodegenDir
-        );
+              const model = await createProjectModel(logger);
 
-        // add support for backoffice extensions
-        const backofficeCodegenDir = join(codegenDir, 'extensions/backoffice');
-        await outputDir(backofficeCodegenDir);
+              await removeUnusedCodegenFiles({ extensionsDir, model });
 
-        if (command === 'dev') {
-          injectRoute({
-            entrypoint: new URL('../runtime/entry.astro', import.meta.url),
-            pattern: `/_wix/extensions/backoffice/[compId]`,
-            prerender: false,
-          });
-
-          chokidar
-            .watch([EXTENSIONS_DIR], {
-              cwd: rootDir,
-              ignoreInitial: true,
-              useFsEvents: false,
-            })
-            .on('all', async () => {
-              model = await createProjectModel(logger);
-              await writeVirtualBackofficeExtensionFiles(
+              await buildComponents({
+                extensionsDir,
+                injectRoute,
+                isDev,
                 model,
-                backofficeCodegenDir
-              );
+              });
             });
-        } else {
-          const backofficeComponents = model.components.filter(
-            isValidBackofficeComponent
-          );
-
-          for (const component of backofficeComponents) {
-            const virtualEntrypoint = join(
-              backofficeCodegenDir,
-              `${component.manifest.compId}.astro`
-            );
-
-            injectRoute({
-              entrypoint: virtualEntrypoint,
-              pattern: `/_wix/extensions/backoffice/${component.manifest.compId}`,
-            });
-          }
         }
-
-        await writeVirtualBackofficeExtensionFiles(model, backofficeCodegenDir);
       },
       'astro:server:setup': ({ logger, server }) => {
         server.middlewares.use(async (req, res, next) => {

package/src/middleware/auth.ts

@@ -12,7 +12,7 @@ export const onRequest: MiddlewareHandler = async (context, next) => {
     sessionTokens: usedTokens,
   };
 
-  const response = await authAsyncLocalStorage.run(store, () => {
+  const response = await authAsyncLocalStorage.run(store, async () => {
     return next();
   });
 

package/src/middleware/html-embeds.ts

@@ -22,7 +22,7 @@ const bodyStartTransformStream = (htmlToInject: string) =>
 async function fetchScripts() {
   return httpClient
     .fetchWithAuth('https://edge.wixapis.com/assets/scripts/v1/site-scripts')
-    .then((res) => res.json() as Promise<{ siteScripts: SiteScript[] }>)
+    .then(async (res) => res.json() as Promise<{ siteScripts: SiteScript[] }>)
     .then((data) => data.siteScripts);
 }
 

package/src/plugins/setupSsrContext.ts

@@ -6,7 +6,7 @@ import { SRC_DIR } from '../directories.js';
 
 // injected routes
 const nonElevatedSetupUrl = new URL(
-  '../build-runtime/context/non-elevated.js',
+  '../build-runtime/context/nonElevated.js',
   import.meta.url
 );
 const elevatedSetupUrl = new URL(

package/src/routes/auth/login.ts

@@ -28,12 +28,14 @@ export const GET: APIRoute = async ({ request, url }) => {
     responseMode: 'query',
   });
 
+  const sameSite = import.meta.env.DEV ? 'None' : 'Lax';
+
   return new Response(null, {
     headers: {
       Location: authUrl,
       'Set-Cookie': `${oAuthStateCookieName}=${JSON.stringify(
         oauthData
-      )}; Max-Age=1800; Path=/; HttpOnly; Secure; SameSite=Lax`,
+      )}; Max-Age=1800; Path=/; HttpOnly; Secure; SameSite=${sameSite}`,
     },
     status: 302,
   });

package/src/routes/{service-plugins.ts → servicePluginsDevRoute.ts}

@@ -3,7 +3,7 @@ import type { APIRoute } from 'astro';
 export const ALL: APIRoute = async (context) => {
   const { ALL } = (await import(
     /* @vite-ignore */
-    `/.astro/integrations/_wix_astro/extensions/service-plugins/${context.params.compId}.ts`
+    `/.astro/integrations/_wix_astro/extensions/service-plugins/${context.params.compId}/entry.ts`
   )) as { ALL: APIRoute };
 
   return ALL(context);

package/src/routes/{webhooks.ts → webhooksDevRoute.ts}

@@ -3,7 +3,7 @@ import type { APIRoute } from 'astro';
 export const ALL: APIRoute = async (context) => {
   const { ALL } = (await import(
     /* @vite-ignore */
-    `/.astro/integrations/_wix_astro/extensions/webhooks/${context.params.compId}.ts`
+    `/.astro/integrations/_wix_astro/extensions/webhooks/${context.params.compId}/entry.ts`
   )) as { ALL: APIRoute };
 
   return ALL(context);

package/src/utils/buildBackofficeComponent.ts

@@ -0,0 +1,66 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { InjectedRoute } from 'astro';
+import { outdent } from 'outdent';
+import type {
+  BackofficeExtensionWidget,
+  BackofficeModal,
+  BackofficePage,
+} from '../components.js';
+import { outputDir, toRelativePath } from './fs-utils.js';
+
+export async function buildBackofficeComponent({
+  codegenDir,
+  component,
+  entryFileName,
+  injectRoute,
+  rootDir,
+}: {
+  codegenDir: string;
+  component: BackofficeExtensionWidget | BackofficeModal | BackofficePage;
+  entryFileName: string;
+  injectRoute: (injectRoute: InjectedRoute) => void;
+  rootDir: string;
+}): Promise<void> {
+  const directory = join(codegenDir, component.manifest.compId);
+
+  await outputDir(directory);
+
+  const entryFilePath = join(rootDir, component.directory, entryFileName);
+
+  const entrypoint = join(directory, `entry.astro`);
+  const HocEntrypoint = join(directory, `wrapper.tsx`);
+
+  await writeFile(
+    HocEntrypoint,
+    outdent`
+      import Component from '${toRelativePath(HocEntrypoint, entryFilePath)}';
+      import { withContextualWixClient } from '@wix/dashboard/internal';
+
+      export const WrappedComponent = withContextualWixClient(Component);
+    `
+  );
+
+  await writeFile(
+    entrypoint,
+    outdent`
+      ---
+      import { WrappedComponent } from '${toRelativePath(entrypoint, HocEntrypoint)}';
+      ---
+
+      <html lang="en">
+        <head></head>
+        <body>
+          <div>
+            <WrappedComponent client:only="react" />
+          </div>
+        </body>
+      </html>
+    `
+  );
+
+  injectRoute({
+    entrypoint,
+    pattern: `/_wix/extensions/backoffice/${component.manifest.compId}`,
+  });
+}

package/src/utils/buildComponents.ts

@@ -0,0 +1,194 @@
+import { join } from 'node:path';
+import type { InjectedRoute } from 'astro';
+import type { Model } from '../types.js';
+import { buildBackofficeComponent } from './buildBackofficeComponent.js';
+import { buildServicePluginComponent } from './buildServicePluginComponent.js';
+import { buildWebhookComponent } from './buildWebhookComponent.js';
+
+export async function buildComponents({
+  extensionsDir,
+  injectRoute: originalInjectRoute,
+  isDev,
+  model,
+}: {
+  extensionsDir: string;
+  injectRoute: (injectRoute: InjectedRoute) => void;
+  isDev: boolean;
+  model: Model;
+}): Promise<void> {
+  const { rootDir } = model;
+
+  // during dev, a single dynamic route is injected so adding or removing
+  // components doesn't require re-running the dev command
+  const injectRoute = isDev ? () => null : originalInjectRoute;
+
+  const backofficeCodegenDir = join(extensionsDir, 'backoffice');
+  const webhooksCodegenDir = join(extensionsDir, 'webhooks');
+  const servicePluginsCodegenDir = join(extensionsDir, 'service-plugins');
+
+  for (const component of model.components) {
+    switch (component.type) {
+      case 'BackofficeExtensionMenuPlugin': {
+        // configuration only
+
+        break;
+      }
+      case 'BackofficeExtensionWidget': {
+        if (
+          component.manifest.compData.backOfficeExtensionWidget.iframeUrl !=
+          null
+        ) {
+          continue;
+        }
+
+        await buildBackofficeComponent({
+          codegenDir: backofficeCodegenDir,
+          component,
+          entryFileName: 'widget.tsx',
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'BackofficeModal': {
+        if (component.manifest.compData.backOfficeModal.iframeUrl != null) {
+          continue;
+        }
+
+        await buildBackofficeComponent({
+          codegenDir: backofficeCodegenDir,
+          component,
+          entryFileName: 'modal.tsx',
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'BackofficePage': {
+        if (component.manifest.compData.backOfficePage.iframeUrl != null) {
+          continue;
+        }
+
+        await buildBackofficeComponent({
+          codegenDir: backofficeCodegenDir,
+          component,
+          entryFileName: 'page.tsx',
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'EcomAdditionalFees': {
+        if (
+          component.manifest.compData.ecomAdditionalFees.deploymentUri != null
+        ) {
+          continue;
+        }
+
+        await buildServicePluginComponent({
+          codegenDir: servicePluginsCodegenDir,
+          component,
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'EcomDiscountsTrigger': {
+        if (
+          component.manifest.compData.ecomDiscountsTrigger.deploymentUri != null
+        ) {
+          continue;
+        }
+
+        await buildServicePluginComponent({
+          codegenDir: servicePluginsCodegenDir,
+          component,
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'EcomGiftCardsProvider': {
+        if (
+          component.manifest.compData.giftCardsProvider.deploymentUri != null
+        ) {
+          continue;
+        }
+
+        await buildServicePluginComponent({
+          codegenDir: servicePluginsCodegenDir,
+          component,
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'EcomPaymentSettings': {
+        if (
+          component.manifest.compData.ecomPaymentSettings.deploymentUri != null
+        ) {
+          continue;
+        }
+
+        await buildServicePluginComponent({
+          codegenDir: servicePluginsCodegenDir,
+          component,
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'EcomShippingRates': {
+        if (
+          component.manifest.compData.ecomShippingRates.deploymentUri != null
+        ) {
+          continue;
+        }
+
+        await buildServicePluginComponent({
+          codegenDir: servicePluginsCodegenDir,
+          component,
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'EcomValidations': {
+        if (component.manifest.compData.ecomValidations.deploymentUri != null) {
+          continue;
+        }
+
+        await buildServicePluginComponent({
+          codegenDir: servicePluginsCodegenDir,
+          component,
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+      case 'Webhook': {
+        if (component.manifest.compData.webhook.callbackUrl != null) {
+          continue;
+        }
+
+        await buildWebhookComponent({
+          codegenDir: webhooksCodegenDir,
+          component,
+          injectRoute,
+          rootDir,
+        });
+
+        break;
+      }
+    }
+  }
+}