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

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.3",
   "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

@@ -26,20 +26,21 @@ import validate from "./validate";
 import { checkNodeVersion } from "./utils";
 import { createManifest } from "./cleanup";
 import { selectWorkspace } from "./workspaceUtils";
-import * as fs from "node:fs/promises";
-import minimist from "minimist";
+import * as fs from "fs";
+const minimist = require("minimist");
 import { initLogger, logError } from "./logger";
 import fg from "fast-glob";
 import * as dotenv from "dotenv";
-import ora from "ora";
-import finalhandler from "finalhandler";
-import serveStatic from "serve-static";
+import { pathToFileURL } from "node:url";
+
 dotenv.config();
 
+const oraP = import("ora");
 let wss: WSServer;
 let changedFiles: string[] = [];
 let browserWindow: ChildProcess | null = null;
 
+let ora: any;
 let previewWorkspace: string;
 
 const SERVER_PORT = 8926;
@@ -52,6 +53,7 @@ const buildWebComponent = async (config: any) => {
 
 const addToGitingore = async () => {
   try {
+    const fs = require("fs").promises;
     const gitignorePath = path.resolve(process.cwd(), ".gitignore");
     const gitignoreContent = await fs.readFile(gitignorePath, "utf8");
 
@@ -81,6 +83,8 @@ export default async () => {
     checkNodeVersion();
     addToGitingore();
 
+    ora = (await oraP).default;
+
     process.on("warning", (e) => console.warn(e.stack));
 
     const logger = createNodeLogger();
@@ -112,6 +116,9 @@ export default async () => {
     breadcrumbs.push("prepare config");
     await prepare(config);
 
+    const finalhandler = require("finalhandler");
+    const serveStatic = require("serve-static");
+
     const serve = serveStatic(config.client.buildDir);
 
     let workspacePreparation = ora("Preparing workspace...").start();
@@ -142,7 +149,7 @@ export default async () => {
     workspacePreparation.succeed("Workspace is ready");
 
     const server = http.createServer(
-      async (request: IncomingMessage, res: ServerResponse) => {
+      (request: IncomingMessage, res: ServerResponse) => {
         res.setHeader("Access-Control-Allow-Origin", "*");
         res.setHeader(
           "Access-Control-Allow-Methods",
@@ -165,7 +172,7 @@ export default async () => {
         try {
           if (request.url?.endsWith(GLOBAL_CSS)) {
             res.writeHead(200, { "Content-Type": "text/css" });
-            res.end(await fs.readFile(config.client.globalCss));
+            res.end(fs.readFileSync(config.client.globalCss));
             return;
           }
         } catch {}
@@ -339,7 +346,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");