@upstart.gg/sdk 0.0.137 → 0.0.139

package/src/shared/utils/tests/schema.test.ts

@@ -1,12 +1,13 @@
 import { describe, expect, test, beforeEach } from "vitest";
 import { type Static, Type } from "@sinclair/typebox";
-import { resolveSchema, validate } from "../schema";
+import { validate, getSchemaDefaults } from "../schema";
 import { toLLMSchema } from "../llm";
 import { sitemapSchema } from "~/shared/sitemap";
 import type { Manifest } from "~/shared/bricks/manifests/text.manifest";
-import { makeFullBrickSchemaForLLM, type Section, sectionSchema } from "~/shared/bricks";
+import { makeFullBrickSchemaForLLM, type Section, sectionProps, sectionSchema } from "~/shared/bricks";
 import type { BrickProps } from "~/shared/bricks/props/types";
 import { type Datarecord, genericDatarecord } from "~/shared/datarecords/types";
+import { defaultTheme, themesArray } from "~/shared/theme";
 
 describe("toLLMSchema tests suite", () => {
   test("should remove metadata properties", () => {
@@ -424,6 +425,206 @@ describe("toLLMSchema consistency", () => {
   });
 });
 
+describe("getSchemaDefaults", () => {
+  test("should generate complete objects when all required properties have defaults", () => {
+    const validSchema = Type.Object(
+      {
+        requiredWithDefault: Type.String({ default: "required default" }),
+        optionalWithDefault: Type.Optional(Type.String({ default: "optional default" })),
+        nested: Type.Object(
+          {
+            nestedRequiredWithDefault: Type.String({ default: "nested required default" }),
+            nestedOptionalWithDefault: Type.Optional(Type.String({ default: "nested optional default" })),
+          },
+          { required: ["nestedRequiredWithDefault"] },
+        ),
+      },
+      { required: ["requiredWithDefault", "nested"] },
+    );
+
+    const result = getSchemaDefaults(validSchema);
+
+    expect(result).toEqual({
+      requiredWithDefault: "required default",
+      optionalWithDefault: "optional default",
+      nested: {
+        nestedRequiredWithDefault: "nested required default",
+        nestedOptionalWithDefault: "nested optional default",
+      },
+    });
+  });
+
+  test("should handle schemas with no required properties", () => {
+    const allOptionalSchema = Type.Object({
+      optional1: Type.Optional(Type.String({ default: "default1" })),
+      optional2: Type.Optional(Type.String({ default: "default2" })),
+      optional3: Type.Optional(Type.String()), // No default
+    });
+
+    const result = getSchemaDefaults(allOptionalSchema);
+
+    expect(result).toEqual({
+      optional1: "default1",
+      optional2: "default2",
+    });
+  });
+
+  test("should handle deeply nested objects with mixed required properties", () => {
+    const deepSchema = Type.Object(
+      {
+        level1: Type.Object(
+          {
+            level2Required: Type.String({ default: "level2 default" }),
+            level2Optional: Type.Optional(Type.String({ default: "level2 optional" })),
+            level2: Type.Object(
+              {
+                level3Required: Type.String(), // Missing default - should break the chain
+                level3WithDefault: Type.String({ default: "level3 default" }),
+              },
+              { required: ["level3Required"] },
+            ),
+          },
+          { required: ["level2Required", "level2"] },
+        ),
+      },
+      { required: ["level1"] },
+    );
+
+    const result = getSchemaDefaults(deepSchema);
+
+    // Should return empty because level3Required lacks a default, making level2 invalid,
+    // which makes level1 invalid, which makes the root invalid
+    expect(result).toEqual({});
+  });
+
+  test("should handle schema with only required properties that all have defaults", () => {
+    const allRequiredSchema = Type.Object(
+      {
+        required1: Type.String({ default: "default1" }),
+        required2: Type.Number({ default: 42 }),
+        required3: Type.Boolean({ default: true }),
+      },
+      { required: ["required1", "required2", "required3"] },
+    );
+
+    const result = getSchemaDefaults(allRequiredSchema);
+
+    expect(result).toEqual({
+      required1: "default1",
+      required2: 42,
+      required3: true,
+    });
+  });
+
+  test("should handle empty required array", () => {
+    const schema = Type.Object(
+      {
+        prop1: Type.String({ default: "default1" }),
+        prop2: Type.Optional(Type.String({ default: "default2" })),
+      },
+      { required: [] },
+    );
+
+    const result = getSchemaDefaults(schema);
+
+    expect(result).toEqual({
+      prop1: "default1",
+      prop2: "default2",
+    });
+  });
+
+  test("should handle mobile/desktop mode defaults", () => {
+    const schemaWithModes = Type.Object(
+      {
+        requiredProp: Type.String({
+          default: "desktop default",
+          "default:mobile": "mobile default",
+        }),
+        optionalProp: Type.Optional(
+          Type.String({
+            default: "desktop optional",
+            "default:mobile": "mobile optional",
+          }),
+        ),
+      },
+      { required: ["requiredProp"] },
+    );
+
+    const desktopResult = getSchemaDefaults(schemaWithModes, "desktop");
+    const mobileResult = getSchemaDefaults(schemaWithModes, "mobile");
+
+    expect(desktopResult).toEqual({
+      requiredProp: "desktop default",
+      optionalProp: "desktop optional",
+    });
+
+    expect(mobileResult).toEqual({
+      requiredProp: "mobile default",
+      optionalProp: "mobile optional",
+    });
+  });
+
+  test("should handle mobile/desktop mode with missing mobile defaults", () => {
+    const schemaWithPartialModes = Type.Object(
+      {
+        requiredProp: Type.String({
+          default: "desktop default",
+          // No mobile default - should fallback to desktop
+        }),
+        optionalProp: Type.Optional(
+          Type.String({
+            default: "desktop optional",
+            "default:mobile": "mobile optional",
+          }),
+        ),
+      },
+      { required: ["requiredProp"] },
+    );
+
+    const mobileResult = getSchemaDefaults(schemaWithPartialModes, "mobile");
+
+    expect(mobileResult).toEqual({
+      requiredProp: "desktop default", // Falls back to desktop default
+      optionalProp: "mobile optional", // Uses mobile default
+    });
+  });
+
+  test("should handle arrays with defaults", () => {
+    const arraySchema = Type.Array(Type.String(), { default: ["item1", "item2"] });
+    const result = getSchemaDefaults(arraySchema);
+    expect(result).toEqual(["item1", "item2"]);
+  });
+
+  test("should handle arrays with mobile/desktop defaults", () => {
+    const arraySchemaWithModes = Type.Array(Type.String(), {
+      default: ["desktop1", "desktop2"],
+      "default:mobile": ["mobile1", "mobile2"],
+    });
+
+    const desktopResult = getSchemaDefaults(arraySchemaWithModes, "desktop");
+    const mobileResult = getSchemaDefaults(arraySchemaWithModes, "mobile");
+
+    expect(desktopResult).toEqual(["desktop1", "desktop2"]);
+    expect(mobileResult).toEqual(["mobile1", "mobile2"]);
+  });
+
+  test("should handle sectionProps", () => {
+    const result = getSchemaDefaults(sectionProps);
+    expect(result).toMatchObject({
+      direction: "flex-row",
+    });
+  });
+
+  test("should handle sectionSchema and its nested properties", () => {
+    const result = getSchemaDefaults(sectionSchema);
+    expect(result).toMatchObject({
+      props: {
+        direction: "flex-row",
+      },
+    });
+  });
+});
+
 describe("validation with validate()", () => {
   test("should validate correct schema with @sinclair/typebox", () => {
     const sectionSchemaLLM = toLLMSchema(sectionSchema);
@@ -535,15 +736,46 @@ describe("validation with validate()", () => {
         content: "Hello, world!",
       },
       mobileProps: {
-        colorPreset: {
-          color: "primary-100",
-        },
+        color: "text-primary-100",
       },
     };
     expect(() => validate(schema, example2)).not.toThrow();
   });
 
-  test("show section schema", () => {
-    console.log("Section schema:", JSON.stringify(sectionSchema));
+  test("should validate arrays", () => {
+    const schema = themesArray;
+    const good = [
+      defaultTheme,
+      {
+        ...defaultTheme,
+        name: "Theme 2",
+      },
+    ];
+    const wrong = [
+      defaultTheme,
+      {
+        ...defaultTheme,
+        name: 42,
+      },
+    ];
+    expect(() => validate(schema, good)).not.toThrow();
+    expect(() => validate(schema, wrong)).toThrow();
+  });
+
+  test("should add default values", () => {
+    const section: Section = {
+      id: "section1",
+      label: "Hero Section",
+      order: 1,
+      props: {
+        colorPreset: {
+          color: "primary-100",
+        },
+      },
+      bricks: [],
+    };
+    const validated = validate<typeof sectionSchema>(sectionSchema, section);
+    expect(() => validate<typeof sectionSchema>(sectionSchema, section)).not.toThrow();
+    expect(validated.props.direction).toBe("flex-row");
   });
 });

package/dist/shared/ai/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/shared/ajv.d.ts

@@ -1,7 +0,0 @@
-import Ajv, { type ErrorObject } from "ajv";
-export type { AnySchemaObject, JSONSchemaType, JSONType, SchemaObject } from "ajv";
-export declare const jsonStringsSupportedFormats: readonly ["date-time", "date", "email", "url"];
-export declare function createAJVInstance(): Ajv;
-export declare const ajv: Ajv;
-export declare function serializeAjvErrors(errors: ErrorObject[] | null | undefined): string;
-//# sourceMappingURL=ajv.d.ts.map

package/dist/shared/ajv.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ajv.d.ts","sourceRoot":"","sources":["../../src/shared/ajv.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,EAAE,EAAE,KAAK,WAAW,EAAE,MAAM,KAAK,CAAC;AAiB5C,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAEnF,eAAO,MAAM,2BAA2B,gDAAiD,CAAC;AAE1F,wBAAgB,iBAAiB,QAmFhC;AAED,eAAO,MAAM,GAAG,KAAsB,CAAC;AAEvC,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAcnF"}