@upstart.gg/sdk 0.0.129 → 0.0.131

package/src/shared/context.ts

@@ -0,0 +1,32 @@
+import type { ImageSearchResultsType } from "./images";
+import type { VersionedPage } from "./page";
+import type { Site } from "./site";
+
+export type GenerationState = {
+  isReady: boolean;
+  isSetup: boolean;
+  hasSitemap: boolean;
+  hasThemesGenerated: boolean;
+};
+
+export type CallContextProps = {
+  /**
+   * The site object
+   */
+  site: Site;
+  /**
+   * Current page. Undefined if flow is "setup" and no page has been created yet.
+   */
+  page: VersionedPage;
+
+  /**
+   * The current generation state of the site. Only used when flow is "setup".
+   */
+  generationState?: GenerationState;
+  /**
+   * The user language guessed from the sitePrompt, if available.
+   */
+  userLanguage?: string;
+
+  assets: ImageSearchResultsType;
+};

package/src/shared/datarecords/external/airtable/handler.ts

@@ -0,0 +1,501 @@
+import type { TObject, TProperties } from "@sinclair/typebox";
+import type { AirtableBases, AirtableFieldType, AirtableOptions } from "./types";
+
+const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+function getClient(token: string) {
+  if (!token) {
+    throw new Error("Missing Airtable API token");
+  }
+
+  return {
+    async callApi<R, P extends Record<string, unknown> = Record<string, unknown>>(
+      path: string,
+      method: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" = "GET",
+      body: P | null = null,
+    ) {
+      const url = `https://api.airtable.com/${path}`;
+      const maxRetries = 5;
+      const retryDelay = 30000; // 30 seconds
+
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          const res = await fetch(url, {
+            method,
+            headers: {
+              Authorization: `Bearer ${token}`,
+              "Content-Type": "application/json",
+            },
+            body: body ? JSON.stringify(body) : undefined,
+          });
+
+          // if 429 is rate limit exceeded
+          if (res.status === 429 && attempt < maxRetries) {
+            console.warn(
+              `Airtable rate limit hit (429) on attempt ${attempt}/${maxRetries}. Waiting ${retryDelay / 1000}s before retry...`,
+            );
+            await sleep(retryDelay);
+            continue; // Retry
+          }
+
+          const data = await res.json();
+
+          // for any other response (success or definitive error)
+          return {
+            status: res.status,
+            success: res.ok,
+            data: data as R,
+          };
+        } catch (error) {
+          // In case of network error, we also retry except on the last attempt
+          if (attempt < maxRetries) {
+            console.warn(
+              `Network error on attempt ${attempt}/${maxRetries}. Waiting ${retryDelay / 1000}s before retry...`,
+              error,
+            );
+            await sleep(retryDelay);
+            continue;
+          }
+          // On the last attempt, we rethrow the error
+          console.error(`Error on attempt ${attempt}/${maxRetries}:`, error);
+          throw error;
+        }
+      }
+
+      // If we reach here, it means we exhausted all attempts with 429
+      throw new Error(`Airtable API rate limit exceeded after ${maxRetries} attempts`);
+    },
+  };
+}
+
+/**
+ * Convert a FormData value based on Airtable field type
+ */
+function convertValueForAirtableField(value: string, fieldType: AirtableFieldType): unknown {
+  switch (fieldType) {
+    case "checkbox":
+      return value === "true" || value === "1" || value.toLowerCase() === "on";
+
+    case "number": {
+      const numValue = Number(value);
+      return Number.isNaN(numValue) ? value : numValue;
+    }
+
+    case "date":
+    case "dateTime":
+      // Airtable expects ISO format strings
+      return value;
+
+    case "email":
+    case "url":
+    case "singleLineText":
+    case "multilineText":
+      return value;
+
+    case "singleSelect":
+      return value;
+
+    case "multipleSelects": {
+      // Handle comma-separated values or JSON array strings
+      if (value.startsWith("[") && value.endsWith("]")) {
+        try {
+          return JSON.parse(value);
+        } catch {
+          return [value];
+        }
+      }
+      if (value.includes(",")) {
+        return value
+          .split(",")
+          .map((v) => v.trim())
+          .filter((v) => v.length > 0);
+      }
+      return [value];
+    }
+
+    default:
+      console.warn(`Unknown Airtable field type: ${fieldType}, treating as text`);
+      return value;
+  }
+}
+
+/**
+ * Fallback conversion based on value patterns (when field type is unknown)
+ */
+function convertValueByPattern(value: string): unknown {
+  // Handle boolean-like values
+  if (value === "true" || value === "false") {
+    return value === "true";
+  }
+
+  // Handle number-like values
+  if (/^\d+\.?\d*$/.test(value)) {
+    const numValue = Number(value);
+    if (!Number.isNaN(numValue)) {
+      return numValue;
+    }
+  }
+
+  // Handle date formats
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value) || /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+    return value;
+  }
+
+  // Handle comma-separated values (potential multiple select)
+  if (value.includes(",")) {
+    const values = value
+      .split(",")
+      .map((v) => v.trim())
+      .filter((v) => v.length > 0);
+    if (values.length > 1) {
+      return values;
+    }
+  }
+
+  // Default to string
+  return value;
+}
+
+export async function saveRecord({
+  formData,
+  options,
+  properties,
+  accessToken,
+}: {
+  formData: FormData;
+  options: AirtableOptions;
+  properties: TProperties;
+  accessToken: string;
+}): Promise<{ id: string } | null> {
+  try {
+    const client = getClient(accessToken);
+    const records: Record<string, unknown> = {};
+
+    for (const [key, value] of formData.entries()) {
+      // Skip empty values
+      if (value === null || value === undefined || value === "") continue;
+
+      // Skip Files for now as they need special handling
+      if (value instanceof File) {
+        console.warn(`File upload not yet supported for field: ${key}`);
+        continue;
+      }
+
+      // Find the field definition in options.fields
+      const fieldDef = options.fields?.find((field) => field.name === key);
+
+      if (fieldDef) {
+        // Use field type information for precise conversion
+        records[key] = convertValueForAirtableField(value, fieldDef.type as AirtableFieldType);
+      } else {
+        // Fallback to pattern-based conversion if field definition not found
+        records[key] = convertValueByPattern(value);
+      }
+    }
+    const response = await client.callApi<{
+      records: Array<{ id: string; fields: Record<string, unknown> }>;
+    }>(`v0/${options.baseId}/${options.tableId}`, "POST", {
+      records: [
+        {
+          fields: records,
+        },
+      ],
+    });
+
+    if (!response.success) {
+      throw new Error(
+        `Failed to push data to Airtable: ${response.status} - ${JSON.stringify(response.data)}`,
+      );
+    }
+
+    return response.data.records[0] ? { id: response.data.records[0].id } : null;
+  } catch (error) {
+    console.error("Error pushing data to Airtable:", error);
+  }
+
+  return null;
+}
+
+/**
+ * Build Airtable table creation data from schema
+ */
+function buildAirtableTableData(properties: TProperties) {
+  // Sort fields by metadata.order (ascending), then fields without order
+  const sortedEntries = Object.entries(properties).sort(([, fieldA], [, fieldB]) => {
+    const orderA = fieldA.metadata?.order;
+    const orderB = fieldB.metadata?.order;
+
+    // If both have order, sort by order value
+    if (orderA !== undefined && orderB !== undefined) {
+      return orderA - orderB;
+    }
+
+    // Fields with order come first
+    if (orderA !== undefined && orderB === undefined) {
+      return -1;
+    }
+
+    if (orderA === undefined && orderB !== undefined) {
+      return 1;
+    }
+
+    // Both without order, maintain original order
+    return 0;
+  });
+
+  const fields = sortedEntries.map(([fieldName, field]) => {
+    // Seulement 3 cas : string, number, boolean
+    if (field.type === "string") {
+      if (field.format === "email") {
+        return {
+          name: fieldName,
+          type: "email",
+        };
+      }
+      if (field.format === "uri") {
+        return {
+          name: fieldName,
+          type: "url",
+        };
+      }
+      if (field.format === "date") {
+        return {
+          name: fieldName,
+          type: "date",
+          options: {
+            dateFormat: {
+              name: "local",
+            },
+          },
+        };
+      }
+      if (field.format === "date-time") {
+        return {
+          name: fieldName,
+          type: "dateTime",
+          options: {
+            dateFormat: {
+              name: "local",
+            },
+            timeFormat: {
+              name: "24hour",
+            },
+            timeZone: "client",
+          },
+        };
+      }
+      if (field.metadata?.["ui:multiline"]) {
+        return {
+          name: fieldName,
+          type: "multilineText",
+        };
+      }
+      if (field.enum) {
+        if (field.metadata?.["ui:widget"] === "checkbox") {
+          return {
+            name: fieldName,
+            type: "multipleSelects",
+            options: {
+              choices: (field.enum as Array<string>).map((value) => ({
+                name: value,
+              })),
+            },
+          };
+        }
+        return {
+          name: fieldName,
+          type: "singleSelect",
+          options: {
+            choices: (field.enum as Array<string>).map((value) => ({
+              name: value,
+            })),
+          },
+        };
+      }
+      return {
+        name: fieldName,
+        type: "singleLineText",
+      };
+    }
+    if (field.type === "boolean") {
+      return {
+        name: fieldName,
+        type: "checkbox",
+        options: {
+          icon: "check",
+          color: "grayBright",
+        },
+      };
+    }
+    if (field.type === "number") {
+      return {
+        name: fieldName,
+        type: "number",
+        options: {
+          precision: 8,
+        },
+      };
+    }
+  });
+
+  return fields;
+}
+
+export async function createTable({
+  name,
+  schema,
+  baseId,
+  accessToken,
+}: {
+  name: string;
+  schema: TObject;
+  baseId: string;
+  accessToken: string;
+}): Promise<AirtableOptions | null> {
+  const fields = buildAirtableTableData(schema.properties);
+  const tableCreationData = {
+    name,
+    description: `Table created by Upstart for ${name}`,
+    fields: fields,
+  };
+  // console.dir(data);
+  try {
+    const client = getClient(accessToken);
+    const response = await client.callApi<{
+      id: string;
+      name: string;
+      description: string;
+      primaryFieldId: string;
+      fields: Array<{
+        id: string;
+        name: string;
+        type: string;
+      }>;
+    }>(`v0/meta/bases/${baseId}/tables`, "POST", tableCreationData);
+
+    if (!response.success) {
+      console.error(
+        "Error while creating Airtable table with:",
+        JSON.stringify(tableCreationData, null, 2),
+        "from schema: ",
+        JSON.stringify(schema, null, 2),
+      );
+      throw new Error(
+        `Failed to create Airtable table: ${response.status} - ${JSON.stringify(response.data)}`,
+      );
+    }
+
+    return {
+      tableId: response.data.id,
+      fields: response.data.fields,
+      tableName: response.data.name,
+      externalUrl: `https://airtable.com/${baseId}/${response.data.id}`,
+    } as AirtableOptions;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error("Unknown error occurred while creating Airtable table", error);
+    }
+    throw error;
+  }
+}
+
+export async function updateTable({
+  baseId,
+  tableId,
+  newName,
+  newProperties,
+  accessToken,
+}: {
+  baseId: string;
+  tableId: string;
+  newName: string;
+  newProperties?: TProperties;
+  accessToken: string;
+}): Promise<AirtableOptions | null> {
+  const client = getClient(accessToken);
+  if (newProperties) {
+    try {
+      const fields = buildAirtableTableData(newProperties);
+      for (const field of fields) {
+        const response = await client.callApi<{
+          id: string;
+          name: string;
+          description: string;
+          type: string;
+        }>(`v0/meta/bases/${baseId}/tables/${tableId}/fields`, "POST", field);
+        if (!response.success) {
+          console.error("Error while adding field to Airtable table with:", JSON.stringify(field, null, 2));
+          throw new Error(
+            `Failed to update Airtable table: ${response.status} - ${JSON.stringify(response.data)}`,
+          );
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(error.message);
+      } else {
+        console.error("Unknown error occurred while updating Airtable table", error);
+      }
+      throw error;
+    }
+  }
+
+  try {
+    const tableUpdateData = {
+      name: newName,
+      description: `Table updated by Upstart for ${newName}`,
+    };
+    const response = await client.callApi<{
+      id: string;
+      name: string;
+      description: string;
+      primaryFieldId: string;
+      fields: Array<{
+        id: string;
+        name: string;
+        type: string;
+      }>;
+    }>(`v0/meta/bases/${baseId}/tables/${tableId}`, "PATCH", tableUpdateData);
+
+    if (!response.success) {
+      console.error("Error while updating Airtable table with:", JSON.stringify(tableUpdateData, null, 2));
+      throw new Error(
+        `Failed to update Airtable table: ${response.status} - ${JSON.stringify(response.data)}`,
+      );
+    }
+
+    return {
+      tableId: response.data.id,
+      fields: response.data.fields,
+      tableName: response.data.name,
+      externalUrl: `https://airtable.com/${baseId}/${response.data.id}`,
+    } as AirtableOptions;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error("Unknown error occurred while creating Airtable table", error);
+    }
+    throw error;
+  }
+}
+
+export async function fetchAirtableBases(accessToken: string): Promise<AirtableBases> {
+  try {
+    const client = getClient(accessToken);
+    const response = await client.callApi<{
+      bases: AirtableBases;
+    }>("v0/meta/bases");
+
+    if (response.success) {
+      return response.data.bases;
+    } else {
+      throw new Error(`Failed to fetch bases: ${response.status}`);
+    }
+  } catch (error) {
+    console.error("Error fetching Airtable bases:", error);
+    return [];
+  }
+}

package/src/shared/datarecords/external/airtable/oauth/config.ts

@@ -0,0 +1,11 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const airtableOAuthTokenSchema = Type.Object({
+  scope: Type.String(),
+  token_type: Type.String(),
+  expires_in: Type.Number(),
+  access_token: Type.String(),
+  refresh_token: Type.String(),
+  refresh_expires_in: Type.Number(),
+});
+export type AirtableOAuthToken = Static<typeof airtableOAuthTokenSchema>;

package/src/shared/datarecords/external/airtable/types.ts

@@ -0,0 +1,63 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const airtableFields = Type.Array(
+  Type.Object({
+    id: Type.String(),
+    name: Type.String(),
+    type: Type.String(),
+  }),
+);
+export type AirtableFields = Static<typeof airtableFields>;
+
+const createAirtableTableResponseSchema = Type.Object({
+  id: Type.String(),
+  name: Type.String(),
+  description: Type.String(),
+  primaryFieldId: Type.String(),
+  fields: airtableFields,
+});
+
+export type CreateAirtableTableResponse = Static<typeof createAirtableTableResponseSchema>;
+
+export const airtableOptions = Type.Object({
+  externalUrl: Type.Optional(Type.String()),
+  baseId: Type.String({
+    pattern: "^app[A-Za-z0-9]+$",
+    description: 'Airtable Base ID starting with "app"',
+  }),
+  baseName: Type.Optional(
+    Type.String({
+      description: "Airtable Base Name",
+    }),
+  ),
+  tableId: Type.String({
+    pattern: "^tbl[A-Za-z0-9]+$",
+    description: 'Airtable Table ID starting with "tbl"',
+  }),
+  tableName: Type.Optional(
+    Type.String({
+      description: "Table name as shown in Airtable interface",
+    }),
+  ),
+  fields: Type.Optional(airtableFields),
+});
+export type AirtableOptions = Static<typeof airtableOptions>;
+
+export type AirtableBases = {
+  id: string;
+  name: string;
+}[];
+
+export const AirtableFieldTypes = Type.Union([
+  Type.Literal("number"),
+  Type.Literal("checkbox"),
+  Type.Literal("date"),
+  Type.Literal("dateTime"),
+  Type.Literal("email"),
+  Type.Literal("url"),
+  Type.Literal("singleLineText"),
+  Type.Literal("multilineText"),
+  Type.Literal("singleSelect"),
+  Type.Literal("multipleSelects"),
+]);
+export type AirtableFieldType = Static<typeof AirtableFieldTypes>;

package/src/shared/datarecords/external/generic-webhook/handler.ts

@@ -0,0 +1,10 @@
+import type { GenericWebhookOptions } from "./options";
+
+export default async function genericWebhookHandler(formData: FormData, options: GenericWebhookOptions) {
+  const result = await fetch(options.url, {
+    method: "POST",
+    body: JSON.stringify(formData),
+    headers: options.headers,
+  });
+  return result.ok;
+}

package/src/shared/datarecords/external/generic-webhook/options.ts

@@ -0,0 +1,13 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const genericWebhookOptions = Type.Object({
+  url: Type.String({ format: "uri", title: "Webhook URL" }),
+  headers: Type.Optional(
+    Type.Record(Type.String(), Type.String(), {
+      title: "Headers",
+      description: "Additional headers to include in the webhook request",
+    }),
+  ),
+});
+
+export type GenericWebhookOptions = Static<typeof genericWebhookOptions>;

package/src/shared/datarecords/external/google/oauth/config.ts

@@ -0,0 +1,30 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+const googleOAuthTokenSchema = Type.Object({
+  access_token: Type.String(),
+  token_type: Type.String(), // Usually "Bearer"
+  expires_in: Type.Number(), // Seconds until token expires, typically 3600 (1 hour)
+  refresh_token: Type.Optional(Type.String()), // Only present in first OAuth exchange
+  scope: Type.String(), // Space-separated list of granted scopes
+  id_token: Type.Optional(Type.String()), // JWT token containing user info, if requested
+});
+
+export type GoogleOAuthToken = Static<typeof googleOAuthTokenSchema>;
+
+// You might also want to define the decoded id_token structure:
+const googleIdTokenSchema = Type.Object({
+  iss: Type.String(), // Issuer (usually 'https://accounts.google.com')
+  sub: Type.String(), // Unique Google ID for the user
+  aud: Type.String(), // Your client ID
+  iat: Type.Number(), // Issued at (timestamp)
+  exp: Type.Number(), // Expiration time (timestamp)
+  email: Type.Optional(Type.String()),
+  email_verified: Type.Optional(Type.Boolean()),
+  name: Type.Optional(Type.String()),
+  picture: Type.Optional(Type.String()),
+  given_name: Type.Optional(Type.String()),
+  family_name: Type.Optional(Type.String()),
+  locale: Type.Optional(Type.String()),
+});
+
+export type GoogleIdToken = Static<typeof googleIdTokenSchema>;