@embeddable.com/sdk-core 3.13.0-next.2 → 3.13.0-next.4

package/lib/push.d.ts

@@ -1,14 +1,25 @@
+import { ResolvedEmbeddableConfig } from "./defineConfig";
 export declare const CUBE_FILES: RegExp;
 export declare const PRESET_FILES: RegExp;
 declare const _default: () => Promise<void>;
 export default _default;
-export declare function archive(ctx: any, yamlFiles: [string, string][], isDev?: boolean): Promise<unknown>;
-export declare function sendBuildByApiKey(ctx: any, { apiKey, email, message }: any): Promise<{
+export declare function buildArchive(config: ResolvedEmbeddableConfig): Promise<import("ora").Ora>;
+export declare function archive(args: {
+    ctx: ResolvedEmbeddableConfig;
+    filesList: [string, string][];
+    isDev: boolean;
+    includeComponents: boolean;
+}): Promise<unknown>;
+export declare function sendBuildByApiKey(ctx: ResolvedEmbeddableConfig, { apiKey, email, message, }: {
+    apiKey: string;
+    email: string;
+    message?: string;
+}): Promise<{
     bundleId: any;
-    email: any;
-    message: any;
+    email: string;
+    message: string | undefined;
 }>;
-export declare function sendBuild(ctx: any, { workspaceId, token }: {
+export declare function sendBuild(ctx: ResolvedEmbeddableConfig, { workspaceId, token }: {
     workspaceId: string;
     token: string;
 }): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "3.13.0-next.2",
+  "version": "3.13.0-next.4",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",

package/src/defineConfig.test.ts

@@ -35,7 +35,7 @@ describe("defineConfig", () => {
     vi.mocked(path.resolve).mockReturnValue(coreRoot);
 
     vi.spyOn(process, "cwd").mockReturnValue(
-      "/embeddable-sdk/packages/core-sdk",
+      "/embeddable-sdk/packages/core-sdk"
     );
   });
 
@@ -75,11 +75,29 @@ describe("defineConfig", () => {
         "plugins": [],
         "previewBaseUrl": "previewBaseUrl",
         "pushBaseUrl": "pushBaseUrl",
+        "pushComponents": true,
+        "pushModels": true,
         "rollbarAccessToken": "rollbarAccessToken",
       }
     `);
   });
 
+  it("throws error for invalid property", () => {
+    expect(() =>
+      defineConfig({ plugins: [], invalidProp: "INVALID" as any } as any)
+    ).toThrow(
+      `Invalid Embeddable Configuration: "": Unrecognized key(s) in object: 'invalidProp'}`
+    );
+  });
+
+  it("throws error for invalid property value", () => {
+    expect(() =>
+      defineConfig({ plugins: [], pushBaseUrl: 123 as any } as any)
+    ).toThrow(
+      `Invalid Embeddable Configuration: "pushBaseUrl": Expected string, received number}`
+    );
+  });
+
   describe("region configuration", () => {
     it("uses legacy-US region by default", () => {
       const config = defineConfig({ plugins: [] });
@@ -129,10 +147,46 @@ describe("defineConfig", () => {
 
     it("throws error for invalid region", () => {
       expect(() =>
-        defineConfig({ plugins: [], region: "INVALID" as any }),
+        defineConfig({ plugins: [], region: "INVALID" as any })
       ).toThrow(
-        "Unsupported region: INVALID. Supported regions are: EU, US, legacy-US",
+        `Invalid Embeddable Configuration: "region": Invalid literal value, expected "legacy-US"}`
       );
     });
   });
+
+  describe("push configuration", () => {
+    it("defaults pushModels and pushComponents to true", () => {
+      const config = defineConfig({ plugins: [] });
+      expect(config.pushModels).toBe(true);
+      expect(config.pushComponents).toBe(true);
+    });
+
+    it("allows overriding pushModels and pushComponents", () => {
+      const config = defineConfig({
+        plugins: [],
+        pushModels: false,
+        pushComponents: false,
+      });
+      expect(config.pushModels).toBe(false);
+      expect(config.pushComponents).toBe(false);
+    });
+
+    it("allows mixed configuration of pushModels and pushComponents", () => {
+      const configModelOnly = defineConfig({
+        plugins: [],
+        pushModels: true,
+        pushComponents: false,
+      });
+      expect(configModelOnly.pushModels).toBe(true);
+      expect(configModelOnly.pushComponents).toBe(false);
+
+      const configComponentOnly = defineConfig({
+        plugins: [],
+        pushModels: false,
+        pushComponents: true,
+      });
+      expect(configComponentOnly.pushModels).toBe(false);
+      expect(configComponentOnly.pushComponents).toBe(true);
+    });
+  });
 });

package/src/defineConfig.ts

@@ -1,6 +1,8 @@
 import * as path from "node:path";
 import { existsSync } from "node:fs";
 import { RollupOptions } from "rollup";
+import { z } from "zod";
+import { errorFormatter } from "@embeddable.com/sdk-utils";
 
 export type Region = "EU" | "US" | "legacy-US";
 
@@ -11,6 +13,8 @@ export type EmbeddableConfig = {
     cleanup: (config: EmbeddableConfig) => Promise<unknown>;
     validate: (config: EmbeddableConfig) => Promise<unknown>;
   })[];
+  pushModels?: boolean;
+  pushComponents?: boolean;
   pushBaseUrl?: string;
   audienceUrl?: string;
   authDomain?: string;
@@ -32,6 +36,47 @@ export type EmbeddableConfig = {
   region?: Region;
 };
 
+export type ResolvedEmbeddableConfig = {
+  core: {
+    rootDir: string;
+    templatesDir: string;
+    configsDir: string;
+  };
+  client: {
+    rootDir: string;
+    srcDir: string;
+    modelsSrc?: string;
+    presetsSrc?: string;
+    buildDir: string;
+    tmpDir: string;
+    globalCss: string;
+    componentDir: string;
+    stencilBuild: string;
+    archiveFile: string;
+    errorFallbackComponent?: string;
+    bundleHash?: string;
+    viteConfig: {
+      resolve?: {
+        alias?: Record<string, string>;
+      };
+    };
+    rollupOptions: RollupOptions;
+  };
+  outputOptions: {
+    typesEntryPointFilename: string;
+  };
+  pushModels: boolean;
+  pushComponents: boolean;
+  pushBaseUrl: string;
+  audienceUrl: string;
+  previewBaseUrl: string;
+  authDomain: string;
+  authClientId: string;
+  applicationEnvironment: string;
+  rollbarAccessToken: string;
+  plugins: EmbeddableConfig["plugins"];
+};
+
 const REGION_CONFIGS = {
   EU: {
     pushBaseUrl: "https://api.eu.embeddable.com",
@@ -56,30 +101,74 @@ const REGION_CONFIGS = {
   },
 };
 
-export default ({
-  plugins,
-  region = "legacy-US",
-  pushBaseUrl,
-  audienceUrl,
-  authDomain,
-  authClientId,
-  errorFallbackComponent,
-  applicationEnvironment,
-  rollbarAccessToken,
-  previewBaseUrl,
-  modelsSrc = "src",
-  presetsSrc = "src",
-  componentsSrc = "src",
-  globalCss = "src/global.css",
-  viteConfig = {},
-  rollupOptions = {},
-}: EmbeddableConfig) => {
-  if (region && !REGION_CONFIGS[region]) {
-    throw new Error(
-      `Unsupported region: ${region}. Supported regions are: ${Object.keys(REGION_CONFIGS).join(", ")}`,
-    );
+export const embeddableConfigSchema = z
+  .object({
+    plugins: z.array(z.function()),
+    region: z
+      .union([z.literal("EU"), z.literal("US"), z.literal("legacy-US")])
+      .optional(),
+    pushModels: z.boolean().optional(),
+    pushComponents: z.boolean().optional(),
+    pushBaseUrl: z.string().optional(),
+    audienceUrl: z.string().optional(),
+    authDomain: z.string().optional(),
+    authClientId: z.string().optional(),
+    errorFallbackComponent: z.string().optional(),
+    applicationEnvironment: z.string().optional(),
+    rollbarAccessToken: z.string().optional(),
+    previewBaseUrl: z.string().optional(),
+    modelsSrc: z.string().optional(),
+    presetsSrc: z.string().optional(),
+    componentsSrc: z.string().optional(),
+    globalCss: z.string().optional(),
+    viteConfig: z
+      .object({
+        resolve: z
+          .object({
+            alias: z.record(z.string()),
+          })
+          .optional(),
+      })
+      .optional(),
+    rollupOptions: z.object({}).optional(),
+  })
+  .strict();
+
+export default (config: EmbeddableConfig) => {
+  const safeParse = embeddableConfigSchema.safeParse(config);
+
+  const errors: string[] = [];
+  if (!safeParse.success) {
+    errorFormatter(safeParse.error.issues).forEach((error) => {
+      errors.push(`${error}`);
+    });
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Invalid Embeddable Configuration: ${errors.join("\n")}}`);
   }
 
+  let {
+    plugins,
+    region = "legacy-US",
+    pushModels = true,
+    pushComponents = true,
+    pushBaseUrl,
+    audienceUrl,
+    authDomain,
+    authClientId,
+    errorFallbackComponent,
+    applicationEnvironment,
+    rollbarAccessToken,
+    previewBaseUrl,
+    modelsSrc = "src",
+    presetsSrc = "src",
+    componentsSrc = "src",
+    globalCss = "src/global.css",
+    viteConfig = {},
+    rollupOptions = {},
+  } = config;
+
   const regionConfig = REGION_CONFIGS[region];
 
   const __dirname = import.meta.dirname;
@@ -145,6 +234,8 @@ export default ({
     outputOptions: {
       typesEntryPointFilename: "embeddable-types-entry-point.js",
     },
+    pushModels,
+    pushComponents,
     pushBaseUrl: pushBaseUrl ?? regionConfig.pushBaseUrl,
     audienceUrl: audienceUrl ?? regionConfig.audienceUrl,
     previewBaseUrl: previewBaseUrl ?? regionConfig.previewBaseUrl,

package/src/dev.ts

@@ -339,7 +339,12 @@ const sendDataModelsAndContextsChanges = async (ctx: any) => {
       path.resolve(ctx.client.buildDir, "embeddable-manifest.json"),
     ]);
 
-    await archive(ctx, filesList, true);
+    await archive({
+      ctx,
+      filesList,
+      isDev: true,
+      includeComponents: false,
+    });
     await sendBuild(ctx, { workspaceId: previewWorkspace, token });
     sending.succeed(`Data models and/or security context synchronized`);
     sendMessage("dataModelsAndOrSecurityContextUpdateSuccess");