@wix/astro 1.0.6 → 1.0.8

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@wix/astro",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "devDependencies": {
-    "@wix/ambassador-devcenter-components-v1-component": "^1.0.459",
-    "@wix/cli-app-definitions": "0.0.0",
-    "@wix/cli-app-manifest": "1.0.0",
-    "@wix/cli-fs": "0.0.0",
     "@wix/dashboard": "^1.3.35",
     "@wix/sdk": "^1.15.17",
-    "@wix/tsup-configs": "0.0.0",
     "astro": "^5.7.4",
     "chalk": "^5.4.1",
     "chokidar": "^3.6.0",
     "globby": "^14.1.0",
+    "is-ci": "^3.0.1",
     "outdent": "^0.8.0",
+    "tsup": "^8.1.0",
     "vite": "6.2.6",
     "zod": "^3.24.2"
   },
@@ -43,5 +40,5 @@
       ]
     }
   },
-  "falconPackageHash": "7d39aaf53bfa18a8c04125afb217d147fe1fa7f35dfd5965258dce4b"
+  "falconPackageHash": "a0b4b875a11bce17302710fe82a519c9bd729f5c60a2b54157afa577"
 }

package/src/directories.ts

@@ -1,17 +1,6 @@
 import { join } from 'node:path';
 
 const SRC_DIR = 'src';
-export const GIT_IGNORED_DIR = '.wix';
-
-const EXTENSIONS_DIR = join(SRC_DIR, 'extensions');
-const DASHBOARD_DIR = join(EXTENSIONS_DIR, 'dashboard');
-
-export const DASHBOARD_PAGES_DIR = join(DASHBOARD_DIR, 'pages');
-export const DASHBOARD_PLUGINS_DIR = join(DASHBOARD_DIR, 'plugins');
-export const DASHBOARD_MENU_PLUGINS_DIR = join(DASHBOARD_DIR, 'menu-plugins');
-export const DASHBOARD_MODALS_DIR = join(DASHBOARD_DIR, 'modals');
 
-const BACKEND_DIR = join(EXTENSIONS_DIR, 'backend');
-
-export const EVENTS_DIR = join(BACKEND_DIR, 'events');
-export const SERVICE_PLUGINS_DIR = join(BACKEND_DIR, 'service-plugins');
+export const GIT_IGNORED_DIR = '.wix';
+export const EXTENSIONS_DIR = join(SRC_DIR, 'extensions');

package/src/index.ts

@@ -1,26 +1,18 @@
 import { join } from 'node:path';
-import type { BuildMetadata } from '@wix/cli-app-definitions';
 import type { AstroConfig, AstroIntegration } from 'astro';
-import { outputDir, writeJson } from '@wix/cli-fs';
 import { envField, passthroughImageService } from 'astro/config';
 import chokidar from 'chokidar';
 import { outdent } from 'outdent';
-import type { Model } from './utils/createProjectModel.js';
-import {
-  DASHBOARD_MENU_PLUGINS_DIR,
-  DASHBOARD_MODALS_DIR,
-  DASHBOARD_PAGES_DIR,
-  DASHBOARD_PLUGINS_DIR,
-  EVENTS_DIR,
-  GIT_IGNORED_DIR,
-  SERVICE_PLUGINS_DIR,
-} from './directories.js';
+import type { Model } from './types.js';
+import { EXTENSIONS_DIR, GIT_IGNORED_DIR } from './directories.js';
 import { patchGlobal } from './plugins/patchGlobal.js';
 import { createProjectModel } from './utils/createProjectModel.js';
+import { outputDir, 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 { resolveBuildMetadata } from './utils/resolveBuildMetadata.js';
 import { writeVirtualBackofficeExtensionFiles } from './utils/writeVirtualBackofficeExtensionFiles.js';
 import { writeVirtualServicePluginExtensionFiles } from './utils/writeVirtualServicePluginExtensionFiles.js';
 import { writeVirtualWebhookExtensionFiles } from './utils/writeVirtualWebhookExtensionFiles.js';
@@ -40,23 +32,19 @@ const createIntegration = (): AstroIntegration => {
           '_wix/app-manifest.json'
         );
 
-        await writeJson(appManifestPath, appManifest);
+        await writeJson(appManifestPath, appManifest, { spaces: 2 });
 
         await writeJson(
           join(_config.root.pathname, GIT_IGNORED_DIR, 'build-metadata.json'),
-          {
-            appManifestPath,
-            clientDir: _config.build.client.pathname,
-            outDir: _config.outDir.pathname,
-            serverDir: _config.build.server.pathname,
-          } satisfies BuildMetadata
+          await resolveBuildMetadata(appManifestPath, _config),
+          { spaces: 2 }
         );
       },
       'astro:config:done': async ({ config }) => {
         _config = config;
       },
       async 'astro:config:setup'({
-        // addMiddleware,
+        addMiddleware,
         command,
         config,
         createCodegenDir,
@@ -126,15 +114,14 @@ const createIntegration = (): AstroIntegration => {
           `
         );
 
-        // TODO This is commented out until BAAS will add support to env var
         // support server side context calls
-        // addMiddleware({
-        //   entrypoint: new URL(
-        //     '../build-runtime/middleware/auth.js',
-        //     import.meta.url
-        //   ),
-        //   order: 'pre',
-        // });
+        addMiddleware({
+          entrypoint: new URL(
+            '../build-runtime/middleware/auth.js',
+            import.meta.url
+          ),
+          order: 'pre',
+        });
 
         updateConfig({
           env: {
@@ -181,7 +168,7 @@ const createIntegration = (): AstroIntegration => {
           });
 
           chokidar
-            .watch([EVENTS_DIR], {
+            .watch([EXTENSIONS_DIR], {
               cwd: config.root.pathname,
               ignoreInitial: true,
               useFsEvents: false,
@@ -192,17 +179,17 @@ const createIntegration = (): AstroIntegration => {
             });
         } else {
           const webhookExtensions = model.extensions.filter((extension) =>
-            isValidWebhookComponent(extension.config)
+            isValidWebhookComponent(extension.manifest)
           );
           for (const extension of webhookExtensions) {
             const virtualEntrypoint = join(
               webhookCodegenDir,
-              `${extension.config.compId}.ts`
+              `${extension.manifest.compId}.ts`
             );
 
             injectRoute({
               entrypoint: virtualEntrypoint,
-              pattern: `/_wix/extensions/webhooks/${extension.config.compId}`,
+              pattern: `/_wix/extensions/webhooks/${extension.manifest.compId}`,
             });
           }
         }
@@ -227,7 +214,7 @@ const createIntegration = (): AstroIntegration => {
           });
 
           chokidar
-            .watch([SERVICE_PLUGINS_DIR], {
+            .watch([EXTENSIONS_DIR], {
               cwd: config.root.pathname,
               ignoreInitial: true,
               useFsEvents: false,
@@ -241,16 +228,16 @@ const createIntegration = (): AstroIntegration => {
             });
         } else {
           const servicePluginExtensions = model.extensions.filter((extension) =>
-            isValidServicePluginComponent(extension.config)
+            isValidServicePluginComponent(extension.manifest)
           );
           for (const extension of servicePluginExtensions) {
             const virtualEntrypoint = join(
               servicePluginCodegenDir,
-              `${extension.config.compId}.ts`
+              `${extension.manifest.compId}.ts`
             );
             injectRoute({
               entrypoint: virtualEntrypoint,
-              pattern: `/_wix/extensions/service-plugins/${extension.config.compId}`,
+              pattern: `/_wix/extensions/service-plugins/${extension.manifest.compId}`,
             });
           }
         }
@@ -272,19 +259,11 @@ const createIntegration = (): AstroIntegration => {
           });
 
           chokidar
-            .watch(
-              [
-                DASHBOARD_PAGES_DIR,
-                DASHBOARD_PLUGINS_DIR,
-                DASHBOARD_MENU_PLUGINS_DIR,
-                DASHBOARD_MODALS_DIR,
-              ],
-              {
-                cwd: config.root.pathname,
-                ignoreInitial: true,
-                useFsEvents: false,
-              }
-            )
+            .watch([EXTENSIONS_DIR], {
+              cwd: config.root.pathname,
+              ignoreInitial: true,
+              useFsEvents: false,
+            })
             .on('all', async () => {
               model = await createProjectModel(logger);
               await writeVirtualBackofficeExtensionFiles(
@@ -294,18 +273,18 @@ const createIntegration = (): AstroIntegration => {
             });
         } else {
           const backofficeExtensions = model.extensions.filter((extension) =>
-            isValidBackofficeComponent(extension.config)
+            isValidBackofficeComponent(extension.manifest)
           );
 
           for (const extension of backofficeExtensions) {
             const virtualEntrypoint = join(
               backofficeCodegenDir,
-              `${extension.config.compId}.astro`
+              `${extension.manifest.compId}.astro`
             );
 
             injectRoute({
               entrypoint: virtualEntrypoint,
-              pattern: `/_wix/extensions/backoffice/${extension.config.compId}`,
+              pattern: `/_wix/extensions/backoffice/${extension.manifest.compId}`,
             });
           }
         }

package/src/schemas.ts

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+
+export const baseComponentSchema = z
+  .object({
+    compData: z.unknown(),
+    compId: z.string(),
+    compName: z.string().optional(),
+    compType: z.string(),
+  })
+  .passthrough();
+
+export type BaseComponent = z.TypeOf<typeof baseComponentSchema>;
+
+const webhookSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      webhook: z
+        .object({
+          callbackUrl: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('WEBHOOK'),
+  })
+);
+
+export type Webhook = z.TypeOf<typeof webhookSchema>;
+
+const backofficeExtensionWidgetSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      backOfficeExtensionWidget: z
+        .object({
+          iframeUrl: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('BACK_OFFICE_EXTENSION_WIDGET'),
+  })
+);
+
+export type BackofficeExtensionWidget = z.TypeOf<
+  typeof backofficeExtensionWidgetSchema
+>;
+
+const backofficeExtensionMenuPluginSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      backOfficeExtensionMenuItem: z
+        .object({
+          iframeUrl: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('BACK_OFFICE_EXTENSION_MENU_ITEM'),
+  })
+);
+
+export type BackofficeExtensionMenuItem = z.TypeOf<
+  typeof backofficeExtensionMenuPluginSchema
+>;
+
+const backofficeModalSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      backOfficeModal: z
+        .object({
+          iframeUrl: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('BACK_OFFICE_MODAL'),
+  })
+);
+
+export type BackofficeModal = z.TypeOf<typeof backofficeModalSchema>;
+
+const backofficePageSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      backOfficePage: z
+        .object({
+          iframeUrl: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('BACK_OFFICE_PAGE'),
+  })
+);
+
+export type BackofficePage = z.TypeOf<typeof backofficePageSchema>;
+
+const ecomAdditionalFeesSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      ecomAdditionalFees: z
+        .object({
+          deploymentUri: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('ECOM_ADDITIONAL_FEES'),
+  })
+);
+
+export type EcomAdditionalFees = z.TypeOf<typeof ecomAdditionalFeesSchema>;
+
+const ecomDiscountsTriggerSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      ecomDiscountsTrigger: z
+        .object({
+          deploymentUri: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('ECOM_DISCOUNTS_TRIGGER'),
+  })
+);
+
+export type EcomDiscountsTrigger = z.TypeOf<typeof ecomDiscountsTriggerSchema>;
+
+const ecomPaymentSettingsSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      ecomPaymentSettings: z
+        .object({
+          deploymentUri: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('ECOM_PAYMENT_SETTINGS'),
+  })
+);
+
+export type EcomPaymentSettings = z.TypeOf<typeof ecomPaymentSettingsSchema>;
+
+const ecomShippingRatesSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      ecomShippingRates: z
+        .object({
+          deploymentUri: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('ECOM_SHIPPING_RATES'),
+  })
+);
+
+export type EcomShippingRates = z.TypeOf<typeof ecomShippingRatesSchema>;
+
+const ecomValidationsSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      ecomValidations: z
+        .object({
+          deploymentUri: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('ECOM_VALIDATIONS'),
+  })
+);
+
+export type EcomValidations = z.TypeOf<typeof ecomValidationsSchema>;
+
+const ecomGiftCardsProviderSchema = baseComponentSchema.merge(
+  z.object({
+    compData: z.object({
+      giftCardsProvider: z
+        .object({
+          deploymentUri: z.string().optional(),
+        })
+        .passthrough(),
+    }),
+    compType: z.literal('GIFT_CARDS_PROVIDER'),
+  })
+);
+
+export type EcomGiftCardsProvider = z.TypeOf<
+  typeof ecomGiftCardsProviderSchema
+>;
+
+export const componentSchema = z.discriminatedUnion('compType', [
+  backofficePageSchema,
+  backofficeExtensionWidgetSchema,
+  backofficeExtensionMenuPluginSchema,
+  backofficeModalSchema,
+  webhookSchema,
+  ecomAdditionalFeesSchema,
+  ecomShippingRatesSchema,
+  ecomDiscountsTriggerSchema,
+  ecomValidationsSchema,
+  ecomPaymentSettingsSchema,
+  ecomGiftCardsProviderSchema,
+]);
+
+export type Component = z.infer<typeof componentSchema>;
+
+export interface AppManifest {
+  appId: string;
+  components: BaseComponent[];
+}

package/src/types.ts

@@ -0,0 +1,19 @@
+import type { BaseComponent, Component } from './schemas.js';
+
+export interface Extension {
+  cwd: string;
+  manifest: Component;
+}
+
+export interface UnknownExtension {
+  cwd: string;
+  manifest: BaseComponent;
+}
+
+export interface Model {
+  appId: string;
+  env: Record<string, string>;
+  extensions: Extension[];
+  rootDir: string;
+  unknownExtensions: UnknownExtension[];
+}

package/src/utils/createProjectModel.ts

@@ -1,110 +1,90 @@
+import { join } from 'node:path';
 import { cwd } from 'node:process';
 import type { AstroIntegrationLogger } from 'astro';
-import {
-  backofficeExtensionMenuPluginSchema,
-  backofficeExtensionWidgetSchema,
-  backofficeModalSchema,
-  backofficePageSchema,
-  servicePluginSchema,
-  webhookSchema,
-} from '@wix/cli-app-manifest';
-import chalk from 'chalk';
+import { globby } from 'globby';
 import { outdent } from 'outdent';
-import { loadEnv } from 'vite';
-import {
-  DASHBOARD_MENU_PLUGINS_DIR,
-  DASHBOARD_MODALS_DIR,
-  DASHBOARD_PAGES_DIR,
-  DASHBOARD_PLUGINS_DIR,
-  EVENTS_DIR,
-  SERVICE_PLUGINS_DIR,
-} from '../directories.js';
-import { loadExtension } from './loadExtension.js';
-
-export type Model = Awaited<ReturnType<typeof createProjectModel>>;
+import type { Extension, Model, UnknownExtension } from '../types.js';
+import { EXTENSIONS_DIR } from '../directories.js';
+import { baseComponentSchema, componentSchema } from '../schemas.js';
+import { pathExists, readJson } from './fs-utils.js';
+import { loadEnvVars } from './loadEnvVars.js';
 
 export async function createProjectModel(logger: AstroIntegrationLogger) {
   const rootDir = cwd();
+  const { appId, env } = loadEnvVars(rootDir, logger);
 
-  const env = loadEnv(process.env.NODE_ENV ?? 'development', process.cwd(), '');
-
-  const appId = env.WIX_CLIENT_ID;
-
-  if (!appId) {
-    logger.error(
-      outdent`
-        Missing environment variable ${chalk.blueBright(`WIX_CLIENT_ID`)}
-        To use the Wix SDK, you must provide the ${chalk.blueBright(
-          'WIX_CLIENT_ID'
-        )} environment variable.
-        💡 To pull the required environment variables from Wix, run:
-          ${chalk.magenta('npx wix edge env --env local pull')}
-        🔍 Need Help?
-        - Visit our docs: https://dev.wix.com/docs/go-headless
-        - Join the community: https://discord.com/channels/1114269395317968906/1288424190969511987
-      `
-    );
-
-    throw new Error(
-      `${chalk.magenta(
-        `WIX_CLIENT_ID`
-      )} not found in loaded environment variables`
-    );
-  }
-
-  const backofficePages = await loadExtension({
-    directory: DASHBOARD_PAGES_DIR,
-    fileName: 'page',
-    rootDir,
-    schema: backofficePageSchema,
+  const extensionsPaths = await globby(join(EXTENSIONS_DIR, '*'), {
+    cwd: rootDir,
+    onlyDirectories: true,
   });
 
-  const backofficePlugins = await loadExtension({
-    directory: DASHBOARD_PLUGINS_DIR,
-    fileName: 'plugin',
-    rootDir,
-    schema: backofficeExtensionWidgetSchema,
-  });
+  const extensions: Extension[] = [];
+  const unknownExtensions: UnknownExtension[] = [];
 
-  const backofficeMenuItems = await loadExtension({
-    directory: DASHBOARD_MENU_PLUGINS_DIR,
-    fileName: 'plugin',
-    rootDir,
-    schema: backofficeExtensionMenuPluginSchema,
-  });
+  for (const extensionPath of extensionsPaths) {
+    const extensionManifest = await readExtensionManifest(extensionPath);
+    const knownAppManifest =
+      await parseKnownExtensionManifest(extensionManifest);
 
-  const backofficeModals = await loadExtension({
-    directory: DASHBOARD_MODALS_DIR,
-    fileName: 'modal',
-    rootDir,
-    schema: backofficeModalSchema,
-  });
+    if (knownAppManifest != null) {
+      extensions.push({
+        cwd: extensionPath,
+        manifest: knownAppManifest,
+      });
 
-  const events = await loadExtension({
-    directory: EVENTS_DIR,
-    fileName: 'event',
-    rootDir,
-    schema: webhookSchema,
-  });
+      continue;
+    }
 
-  const servicePlugins = await loadExtension({
-    directory: SERVICE_PLUGINS_DIR,
-    fileName: 'plugin',
-    rootDir,
-    schema: servicePluginSchema,
-  });
+    const unknownAppManifest =
+      await parseBaseExtensionManifest(extensionManifest);
+
+    unknownExtensions.push({
+      cwd: extensionPath,
+      manifest: unknownAppManifest,
+    });
+  }
 
   return {
     appId,
     env,
-    extensions: [
-      ...backofficeMenuItems,
-      ...backofficeModals,
-      ...backofficePages,
-      ...backofficePlugins,
-      ...events,
-      ...servicePlugins,
-    ],
+    extensions,
     rootDir,
-  };
+    unknownExtensions,
+  } satisfies Model;
+}
+
+async function parseKnownExtensionManifest(extensionManifest: unknown) {
+  const appManifestResult = componentSchema.safeParse(extensionManifest);
+
+  if (appManifestResult.error) {
+    return null;
+  }
+
+  return appManifestResult.data;
+}
+
+async function parseBaseExtensionManifest(extensionManifest: unknown) {
+  const appManifestResult = baseComponentSchema.safeParse(extensionManifest);
+
+  if (!appManifestResult.success) {
+    throw new Error(outdent`
+      Invalid extension configuration:
+
+      ${appManifestResult.error.errors
+        .map((e) => `${e.path.join('.')}: ${e.message}`)
+        .join('\n')}
+    `);
+  }
+
+  return appManifestResult.data;
+}
+
+async function readExtensionManifest(directoryPath: string) {
+  const manifestFilePath = join(directoryPath, 'extension.json');
+
+  if (!(await pathExists(manifestFilePath))) {
+    throw new Error('Missing extension manifest');
+  }
+
+  return await readJson(manifestFilePath);
 }

package/src/utils/fs-utils.ts

@@ -0,0 +1,37 @@
+import {
+  access,
+  readFile as fsReadFile,
+  mkdir,
+  writeFile,
+} from 'node:fs/promises';
+import { EOL } from 'node:os';
+import { dirname } from 'node:path';
+
+function toJsonString(object: unknown, opts?: { spaces: number }) {
+  return JSON.stringify(object, null, opts?.spaces).concat(EOL);
+}
+
+export async function writeJson(
+  filePath: string,
+  object: unknown,
+  opts?: { spaces: number }
+) {
+  const str = toJsonString(object, opts);
+  await outputDir(dirname(filePath));
+
+  await writeFile(filePath, str, 'utf-8');
+}
+
+export async function readJson(file: string): Promise<unknown> {
+  return JSON.parse(await fsReadFile(file, 'utf-8'));
+}
+
+export function pathExists(path: string) {
+  return access(path)
+    .then(() => true)
+    .catch(() => false);
+}
+
+export async function outputDir(dir: string) {
+  await mkdir(dir, { recursive: true });
+}