@upstart.gg/sdk 0.0.137 → 0.0.139

package/src/shared/bricks.ts

@@ -101,15 +101,37 @@ export const brickSchema = Type.Object({
 });
 
 export function makeFullBrickSchemaForLLM(type: string, otherTypes?: string[]) {
-  const originalProps = Type.Pick(brickSchema, ["props"]);
-  const props = otherTypes
-    ? Type.Composite([
-        Type.Omit(brickSchema, ["props"]),
-        Type.Object({
-          props: Type.Composite([
-            originalProps,
-            Type.Object({
-              $children: Type.Union(
+  if (!otherTypes || !otherTypes.length) {
+    return toLLMSchema(
+      Type.Object(
+        {
+          id: Type.String({
+            title: "ID",
+            description: "A unique identifier for the brick.",
+          }),
+          type: Type.Literal(type),
+          props: manifests[type].props,
+          // Mobileprops are always partial and do not contain $children
+          mobileProps: Type.Optional(Type.Partial(Type.Omit(manifests[type].props, ["$children"]))),
+        },
+        // IMPORTANT: DO NOT set "additionalProperties" to `false` because it would break validation with Cabidela library
+        // { additionalProperties: false },
+      ),
+    );
+  }
+  return toLLMSchema(
+    Type.Object(
+      {
+        id: Type.String({
+          title: "ID",
+          description: "A unique identifier for the brick.",
+        }),
+        type: Type.Literal(type),
+        props: Type.Composite([
+          brickSchema.properties.props,
+          Type.Object({
+            $children: Type.Array(
+              Type.Union(
                 otherTypes.map((t) =>
                   Type.Object({
                     id: Type.String({
@@ -118,24 +140,13 @@ export function makeFullBrickSchemaForLLM(type: string, otherTypes?: string[]) {
                     }),
                     type: Type.Literal(t),
                     props: manifests[t].props,
-                    mobileProps: Type.Optional(Type.Partial(manifests[t].props)),
+                    mobileProps: Type.Optional(Type.Partial(Type.Omit(manifests[t].props, ["$children"]))),
                   }),
                 ),
               ),
-            }),
-          ]),
-        }),
-      ])
-    : manifests[type].props;
-  return toLLMSchema(
-    Type.Object(
-      {
-        id: Type.String({
-          title: "ID",
-          description: "A unique identifier for the brick.",
-        }),
-        type: Type.Literal(type),
-        props,
+            ),
+          }),
+        ]),
         mobileProps: Type.Optional(Type.Partial(manifests[type].props)),
       },
       // IMPORTANT: DO NOT set "additionalProperties" to `false` because it would break validation with Cabidela library

package/src/shared/datarecords/types.ts

@@ -1,4 +1,4 @@
-import { Type, type Static } from "@sinclair/typebox";
+import { type TSchema, Type, type Static } from "@sinclair/typebox";
 import { airtableOptions } from "./external/airtable/types";
 import { googleSheetsOptions } from "./external/google/sheets/types";
 import { notionOptions } from "./external/notion/types";
@@ -12,23 +12,27 @@ const internalDatarecord = Type.Object(
   {
     provider: Type.Literal("internal"),
     // options: Type.Optional(Type.Any()),
-    schema: Type.Any({
-      title: "Schema",
-      description:
-        "JSON Schema of the datarecord. Always of type 'object' and representing a row that will be saved in the database.",
-      examples: [
-        {
-          type: "object",
-          properties: {
-            firstname: { type: "string", title: "Firstname" },
-            lastname: { type: "string", title: "Lastname" },
-            email: { type: "string", format: "email", title: "Email" },
+    schema: Type.Object(
+      {},
+      {
+        title: "Schema",
+        additionalProperties: true,
+        description:
+          "JSON Schema of the datarecord. Always of type 'object' and representing a row that will be saved in the database.",
+        examples: [
+          {
+            type: "object",
+            properties: {
+              firstname: { type: "string", title: "Firstname" },
+              lastname: { type: "string", title: "Lastname" },
+              email: { type: "string", format: "email", title: "Email" },
+            },
+            required: ["email"],
+            title: "Newsletter Subscription",
           },
-          required: ["email"],
-          title: "Newsletter Subscription",
-        },
-      ],
-    }),
+        ],
+      },
+    ),
     indexes: Type.Array(
       Type.Object(
         {
@@ -85,23 +89,27 @@ const internalDatarecord = Type.Object(
 
 // Schema commun à tous les datarecords
 const commonDatarecordSchema = Type.Object({
-  schema: Type.Any({
-    title: "Schema",
-    description:
-      "JSON Schema of the datarecord. Always of type 'object' and representing a row that will be saved.",
-    examples: [
-      {
-        type: "object",
-        properties: {
-          firstname: { type: "string", title: "Firstname" },
-          lastname: { type: "string", title: "Lastname" },
-          email: { type: "string", format: "email", title: "Email" },
+  schema: Type.Object(
+    {},
+    {
+      additionalProperties: true,
+      title: "Schema",
+      description:
+        "JSON Schema of the datarecord. Always of type 'object' and representing a row that will be saved.",
+      examples: [
+        {
+          type: "object",
+          properties: {
+            firstname: { type: "string", title: "Firstname" },
+            lastname: { type: "string", title: "Lastname" },
+            email: { type: "string", format: "email", title: "Email" },
+          },
+          required: ["email"],
+          title: "Newsletter Subscription",
         },
-        required: ["email"],
-        title: "Newsletter Subscription",
-      },
-    ],
-  }),
+      ],
+    },
+  ),
 });
 
 const commonDatarecordMetadata = Type.Object({

package/src/shared/datasources/external/rss/fetcher.ts

@@ -19,12 +19,6 @@ const fetchRss: DatasourceFetcher<RssSchema, null, RssOptions> = async ({
       pubDate: item.published ? item.published.toISOString() : new Date().toISOString(),
     })) ?? [];
 
-  // const isValid = ajv.validate<RssSchema>(rssSchema, newFeed);
-
-  // if (!isValid) {
-  //   throw new Error(`fetchRss Error: Invalid Feed data (${url}): ${serializeAjvErrors(ajv.errors)}`);
-  // }
-
   return newFeed;
 };
 

package/src/shared/datasources.ts

@@ -1,4 +1,4 @@
-import type { TArray } from "@sinclair/typebox";
+import { type Static, Type, type TArray } from "@sinclair/typebox";
 import type { Datasource } from "./datasources/types";
 
 /**
@@ -16,6 +16,15 @@ export function defineDatasource<D extends Datasource>(datasource: D) {
   };
 }
 
+export const datasourceSystemProperties = Type.Object({
+  $id: Type.Optional(Type.String({ title: "Id", format: "text" })),
+  $publicationDate: Type.Optional(Type.String({ title: "Publication Date", format: "date-time" })),
+  $slug: Type.Optional(Type.String({ title: "Slug", format: "slug" })),
+  $lastModificationDate: Type.Optional(Type.String({ title: "Last Modification", format: "date-time" })),
+});
+
+export type DatasourceSystemProperties = Static<typeof datasourceSystemProperties>;
+
 /**
  * Map a datasource schema to include $id, $createdAt, and $updatedAt properties.
  */
@@ -28,11 +37,10 @@ export function mapDatasourceSchemaWithInternalProperties(schema: TArray): Datas
       type: "object",
       properties: {
         ...items.properties,
-        $id: { type: "string", title: "Id" },
-        $slug: { type: "string", format: "slug", title: "Slug" },
-        $publicationDate: { type: "string", format: "date-time", title: "Publication Date" },
-        $lastModificationDate: { type: "string", format: "date-time", title: "Last Modification Date" },
+        ...datasourceSystemProperties.properties,
       },
+      // We should likely reuse `datasourceSystemProperties.required` instead of hardcoding but I'm not sure
+      // how the dashboard is handling it right now when creating new items
       required: Array.from(new Set(["$id", "$slug", "$lastModificationDate", ...items.required])),
     },
   };

package/src/shared/page.ts

@@ -6,6 +6,7 @@ export const pageSchema = Type.Object({
   id: Type.String({
     description: "The unique ID of the page. Use a human readable url-safe slug",
     examples: ["home", "about-us", "products-list"],
+    pattern: "^[a-z0-9-_]+$",
   }),
   label: Type.String({
     description: "The label (name) of the page",

package/src/shared/prompt.ts

@@ -2,7 +2,7 @@ import { type Static, Type } from "@sinclair/typebox";
 
 export const sitePrompt = Type.String({
   minLength: 30,
-  maxLength: 500,
+  maxLength: 1000,
   description: "User prompt for the site, describing the purpose and main features of the site.",
 });
 

package/src/shared/site.ts

@@ -47,11 +47,13 @@ export function createEmptyConfig(sitePrompt: string): SiteAndPagesConfig {
     // we need a fake page
     pages: [
       {
+        // Keep this fake id as is!
         id: "_default_",
-        label: "First page",
+        label: "Untitled",
         sections: [],
         attributes: resolvePageAttributes({
           path: "/",
+          isInitialPage: true,
         }),
       },
     ],

package/src/shared/sitemap.ts

@@ -18,10 +18,17 @@ export const sitemapEntry = Type.Composite(
             "The status of the page. Can be draft or published. [AI instructions: Dont generate this.]",
         }),
       ),
+      isInitialPage: Type.Optional(
+        Type.Boolean({
+          title: "Is initial page",
+          "ai:hidden": true,
+        }),
+      ),
     }),
   ],
   {
     description: "Pages map. The complete list of site pages & their metadata",
+    additionalProperties: true,
   },
 );
 

package/src/shared/utils/schema.ts

@@ -1,9 +1,8 @@
-import { type TArray, type TObject, type TSchema, Kind, type Static } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
+import type { TArray, TObject, TSchema, Static } from "@sinclair/typebox";
 import type { PageAttributes } from "../attributes";
-import { defaultsDeep as applyDefaultsDeep, merge } from "lodash-es";
+import { defaultsDeep as applyDefaultsDeep } from "lodash-es";
 import { FormatRegistry } from "@sinclair/typebox";
-import { DefaultErrorFunction, SetErrorFunction, ValueErrorType } from "@sinclair/typebox/errors";
+import { Validator } from "@cfworker/json-schema";
 // export const jsonStringsSupportedFormats = ["date-time", "date", "email", "url"] as const;
 
 // import string enum for its side effects
@@ -34,21 +33,6 @@ FormatRegistry.Set("password", noCheck);
 FormatRegistry.Set("image", urlValidator);
 FormatRegistry.Set("file", urlValidator);
 
-SetErrorFunction((error) => {
-  if (error.errorType === ValueErrorType.Kind) {
-    if (
-      error.schema.type === "string" &&
-      typeof error.value === "string" &&
-      error.schema.enum &&
-      !error.schema.enum.includes(error.value)
-    ) {
-      return `Must include valid value: [${error.schema.enum.join(", ")}]`;
-    }
-  }
-
-  return DefaultErrorFunction(error);
-});
-
 export function normalizeSchemaEnum(schema: TSchema): Array<{ const: string; title: string }> {
   if (!("enum" in schema)) {
     return schema.anyOf ?? schema.oneOf;
@@ -73,18 +57,18 @@ export function getSchemaDefaults<T extends TObject | TArray>(
   // Handle object schemas
   if (schema.type === "object" && "properties" in schema) {
     const objectSchema = schema as TObject;
-    const defaults: Static<T> = {};
 
+    // First pass: collect all properties that have defaults
+    const propertiesWithDefaults: Record<string, unknown> = {};
     for (const [key, propertySchema] of Object.entries(objectSchema.properties)) {
       const defaultValue = getNestedDefaults(propertySchema as TSchema, mode);
-
-      // Only include properties that have explicit defaults
       if (defaultValue !== undefined) {
-        defaults[key] = defaultValue;
+        propertiesWithDefaults[key] = defaultValue;
       }
     }
 
-    return defaults as Static<T>;
+    // If we get here, all required properties have defaults, so we can include all properties
+    return propertiesWithDefaults as Static<T>;
   }
 
   // Handle array schemas
@@ -120,18 +104,27 @@ function getNestedDefaults(schema: TSchema, mode?: "mobile" | "desktop"): unknow
   // Handle nested object schemas
   if (schema.type === "object" && "properties" in schema) {
     const objectSchema = schema as TObject;
-    const defaults: Record<string, unknown> = {};
+    const required = objectSchema.required || [];
 
+    // First pass: collect all properties that have defaults
+    const propertiesWithDefaults: Record<string, unknown> = {};
     for (const [key, propertySchema] of Object.entries(objectSchema.properties)) {
       const defaultValue = getNestedDefaults(propertySchema as TSchema, mode);
-
-      // Only include properties that have explicit defaults
       if (defaultValue !== undefined) {
-        defaults[key] = defaultValue;
+        propertiesWithDefaults[key] = defaultValue;
       }
     }
 
-    return Object.keys(defaults).length > 0 ? defaults : undefined;
+    // Second pass: validate that all required properties have defaults
+    // If any required property lacks a default, this nested object cannot be included
+    for (const requiredProp of required) {
+      if (!(requiredProp in propertiesWithDefaults)) {
+        return undefined;
+      }
+    }
+
+    // If we get here, all required properties have defaults
+    return Object.keys(propertiesWithDefaults).length > 0 ? propertiesWithDefaults : undefined;
   }
 
   // Handle nested array schemas
@@ -167,35 +160,21 @@ export function filterSchemaProperties(schema: TObject, filter: (prop: TSchema)
   return extractProperties(schema);
 }
 
-/**
- * Resolves a JSON schema by following $ref references recursively.
- * Handles nested objects, arrays, and complex schema structures.
- */
-export function resolveSchema<T extends TSchema = TSchema>(schema: T): T {
-  console.warn("resolveSchema is deprecated, use resolveSchemaRecursive instead");
-  return schema;
-}
-
 export function validate<T extends TSchema>(schema: TSchema, data: unknown): Static<T> {
-  try {
-    const valid = Value.Check(schema, data);
-    if (!valid) {
-      let finalError = "";
-      for (const error of Value.Errors(schema, data)) {
-        finalError += `Error at ${error.path} with value ${error.value}: ${error.message}\n`;
-      }
-      console.error("Validation errors:\n", finalError);
-      throw new Error(finalError);
+  const validator = new Validator(schema, "7", false);
+  const result = validator.validate(data);
+  if (!result.valid) {
+    const errors = [];
+    for (const error of result.errors) {
+      errors.push(`${error.error} (at ${error.keywordLocation})`);
     }
-  } catch (e) {
-    console.error("Validation exception:", e);
-    console.dir(e, { depth: null });
-    throw e;
+    const formatedError = `- ${errors.join("\n- ")}`;
+    throw new Error(formatedError);
   }
 
   // Mutate data with defaults
   const defaults = getSchemaDefaults(schema as TObject | TArray);
-  const finalObject = applyDefaultsDeep({}, data, defaults);
+  const finalObject = Array.isArray(data) ? data : applyDefaultsDeep({}, data, defaults);
 
   return finalObject as Static<T>;
 }