@upstart.gg/sdk 0.0.129 → 0.0.131

package/src/shared/datasources/internal/job-board/schema.ts

@@ -0,0 +1,228 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const jobBoardCompanySchema = Type.Object(
+  {
+    basicInfo: Type.Object({
+      name: Type.String({
+        title: "Company Name",
+      }),
+      legalName: Type.Optional(
+        Type.String({
+          title: "Legal Company Name",
+        }),
+      ),
+      industry: Type.Array(
+        Type.String({
+          title: "Industry",
+          description: "Industries the company operates in",
+        }),
+      ),
+      companySize: Type.String({
+        enum: ["1-10", "11-50", "51-200", "201-500", "501-1000", "1000+"],
+        title: "Company Size",
+      }),
+      foundedYear: Type.Optional(
+        Type.Number({
+          title: "Founded Year",
+          minimum: 1800,
+          maximum: 2025,
+        }),
+      ),
+      description: Type.String({
+        title: "Company Description",
+        minLength: 1,
+        maxLength: 5000,
+        format: "markdown",
+      }),
+    }),
+
+    contact: Type.Object({
+      email: Type.String({
+        title: "Company Email",
+        pattern: "^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
+      }),
+      phone: Type.Optional(
+        Type.String({
+          title: "Company Phone",
+          pattern: "^\\+?[1-9]\\d{1,14}$",
+        }),
+      ),
+      website: Type.String({
+        title: "Company Website",
+        pattern: "^https?://.*",
+      }),
+      socialMedia: Type.Optional(
+        Type.Object({
+          linkedin: Type.Optional(Type.String()),
+          twitter: Type.Optional(Type.String()),
+          facebook: Type.Optional(Type.String()),
+        }),
+      ),
+    }),
+
+    location: Type.Object({
+      headquarters: Type.Object({
+        address: Type.Optional(Type.String()),
+        city: Type.String(),
+        state: Type.Optional(Type.String()),
+        country: Type.String(),
+        postalCode: Type.Optional(Type.String()),
+      }),
+      hasRemoteWorkPolicy: Type.Boolean({
+        title: "Offers Remote Work",
+        default: false,
+      }),
+      offices: Type.Optional(
+        Type.Array(
+          Type.Object({
+            city: Type.String(),
+            state: Type.Optional(Type.String()),
+            country: Type.String(),
+          }),
+        ),
+      ),
+    }),
+  },
+  {
+    description: "Schema representing a job board listing with company and job details",
+  },
+);
+
+export const jobBoardListingSchema = Type.Array(
+  Type.Object({
+    id: Type.String({
+      title: "Job ID",
+      description: "Unique identifier for the job posting",
+    }),
+    basicInfo: Type.Object({
+      title: Type.String({
+        title: "Job Title",
+      }),
+      department: Type.String({
+        title: "Department",
+      }),
+      employmentType: Type.Array(
+        Type.String({
+          enum: ["Full-time", "Part-time", "Contract", "Temporary", "Internship", "Freelance"],
+        }),
+      ),
+      experienceLevel: Type.String({
+        enum: ["Entry", "Associate", "Mid-Senior", "Senior", "Lead", "Executive"],
+      }),
+      workplaceType: Type.String({
+        enum: ["On-site", "Hybrid", "Remote"],
+      }),
+    }),
+
+    compensation: Type.Object({
+      salary: Type.Optional(
+        Type.Object({
+          min: Type.Number({
+            minimum: 0,
+          }),
+          max: Type.Number({
+            minimum: 0,
+          }),
+          currency: Type.String({
+            default: "USD",
+          }),
+          period: Type.String({
+            enum: ["Hour", "Day", "Week", "Month", "Year"],
+          }),
+        }),
+      ),
+      benefits: Type.Optional(
+        Type.Array(
+          Type.String({
+            enum: [
+              "Health Insurance",
+              "Dental Insurance",
+              "Vision Insurance",
+              "401(k)",
+              "Stock Options",
+              "Paid Time Off",
+              "Professional Development",
+              "Gym Membership",
+              "Remote Work",
+              "Flexible Hours",
+              "Other",
+            ],
+          }),
+        ),
+      ),
+      additionalCompensation: Type.Optional(Type.String()),
+    }),
+
+    details: Type.Object({
+      description: Type.String({
+        title: "Job Description",
+        minLength: 1,
+        maxLength: 10000,
+      }),
+      responsibilities: Type.Array(Type.String()),
+      requirements: Type.Object({
+        required: Type.Array(Type.String()),
+        preferred: Type.Optional(Type.Array(Type.String())),
+      }),
+      skills: Type.Array(
+        Type.Object({
+          name: Type.String(),
+          level: Type.Optional(
+            Type.String({
+              enum: ["Beginner", "Intermediate", "Advanced", "Expert"],
+            }),
+          ),
+          required: Type.Boolean({
+            default: true,
+          }),
+        }),
+      ),
+    }),
+
+    applicationProcess: Type.Object({
+      howToApply: Type.String({
+        enum: ["Direct", "External", "Email"],
+      }),
+      applicationUrl: Type.Optional(Type.String()),
+      applicationEmail: Type.Optional(
+        Type.String({
+          pattern: "^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
+        }),
+      ),
+      requiredDocuments: Type.Array(
+        Type.String({
+          enum: ["Resume", "Cover Letter", "Portfolio", "References", "Other"],
+        }),
+      ),
+    }),
+
+    metadata: Type.Object({
+      postingDate: Type.String({
+        title: "Posting Date",
+        format: "date",
+      }),
+      expirationDate: Type.Optional(
+        Type.String({
+          title: "Expiration Date",
+          format: "date",
+        }),
+      ),
+      status: Type.String({
+        enum: ["Draft", "Active", "Paused", "Filled", "Expired", "Cancelled"],
+        default: "Draft",
+      }),
+      isSponsored: Type.Boolean({
+        default: false,
+      }),
+      isRemoteEligible: Type.Boolean({
+        default: false,
+      }),
+      isVisaSponsored: Type.Boolean({
+        default: false,
+      }),
+    }),
+  }),
+);
+
+export type JobBoardCompanyType = Static<typeof jobBoardCompanySchema>;
+export type JobBoardListingType = Static<typeof jobBoardListingSchema>;

package/src/shared/datasources/internal/links/schema.ts

@@ -0,0 +1,15 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const linksSchema = Type.Array(
+  Type.Object({
+    url: Type.String({ format: "uri", title: "URL" }),
+    title: Type.String({ title: "Title" }),
+    description: Type.Optional(Type.String({ title: "Description", format: "markdown" })),
+    icon: Type.Optional(Type.String({ title: "Icon", format: "uri" })),
+  }),
+  {
+    description: "Schema representing a collection of links",
+  },
+);
+
+export type LinksSchema = Static<typeof linksSchema>;

package/src/shared/datasources/internal/recipes/schema.ts

@@ -0,0 +1,42 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const recipesSchema = Type.Array(
+  Type.Object({
+    title: Type.String({
+      title: "Title",
+    }),
+    description: Type.String({
+      title: "Description",
+      format: "markdown",
+    }),
+    time: Type.String({
+      title: "Time to prepare the recipe",
+    }),
+    ingredients: Type.Array(
+      Type.Object({
+        name: Type.String({
+          title: "Name of the ingredient",
+        }),
+        quantity: Type.String({
+          title: "Quantity of the ingredient",
+        }),
+      }),
+    ),
+    steps: Type.Array(
+      Type.Object({
+        title: Type.String({
+          title: "Step title",
+        }),
+        description: Type.String({
+          title: "Step description",
+        }),
+      }),
+    ),
+  }),
+  {
+    title: "Recipes",
+    description: "Collection of recipes",
+  },
+);
+
+export type RecipesSchema = Static<typeof recipesSchema>;

package/src/shared/datasources/internal/restaurant/schema.ts

@@ -0,0 +1,225 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const restaurantSchema = Type.Object(
+  {
+    basicInfo: Type.Object({
+      name: Type.String({
+        title: "Restaurant Name",
+      }),
+      legalName: Type.Optional(
+        Type.String({
+          title: "Legal Business Name",
+        }),
+      ),
+      taxId: Type.Optional(
+        Type.String({
+          title: "Tax ID/VAT Number",
+        }),
+      ),
+      establishedDate: Type.String({
+        title: "Establishment Date",
+        format: "date",
+      }),
+      cuisine: Type.Array(
+        Type.String({
+          title: "Cuisine Type",
+          description: "Types of cuisine served",
+        }),
+      ),
+    }),
+
+    contact: Type.Object({
+      email: Type.String({
+        title: "Email",
+        pattern: "^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
+      }),
+      phone: Type.String({
+        title: "Phone Number",
+        pattern: "^\\+?[1-9]\\d{1,14}$",
+      }),
+      socialMedia: Type.Optional(
+        Type.Object({
+          facebook: Type.Optional(Type.String()),
+          instagram: Type.Optional(Type.String()),
+          twitter: Type.Optional(Type.String()),
+        }),
+      ),
+    }),
+
+    location: Type.Object({
+      address: Type.String({
+        title: "Street Address",
+      }),
+      city: Type.String({
+        title: "City",
+      }),
+      state: Type.Optional(
+        Type.String({
+          title: "State/Province",
+        }),
+      ),
+      postalCode: Type.String({
+        title: "Postal Code",
+      }),
+      country: Type.String({
+        title: "Country",
+      }),
+      coordinates: Type.Optional(
+        Type.Object({
+          latitude: Type.Number(),
+          longitude: Type.Number(),
+        }),
+      ),
+    }),
+
+    hours: Type.Object({
+      regularHours: Type.Array(
+        Type.Object({
+          day: Type.String({
+            enum: ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"],
+          }),
+          open: Type.String({
+            title: "Opening Time",
+            pattern: "^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$",
+          }),
+          close: Type.String({
+            title: "Closing Time",
+            pattern: "^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$",
+          }),
+          closed: Type.Optional(
+            Type.Boolean({
+              title: "Closed on this day",
+              default: false,
+            }),
+          ),
+        }),
+      ),
+      specialHours: Type.Optional(
+        Type.Array(
+          Type.Object({
+            date: Type.String({
+              title: "Special Date",
+              format: "date",
+            }),
+            description: Type.String({
+              title: "Description",
+            }),
+            open: Type.Optional(Type.String()),
+            close: Type.Optional(Type.String()),
+            closed: Type.Boolean({
+              default: false,
+            }),
+          }),
+        ),
+      ),
+    }),
+
+    menu: Type.Object({
+      categories: Type.Array(
+        Type.Object({
+          name: Type.String({
+            title: "Category Name",
+            description: "E.g., Starters, Main Course, Desserts",
+          }),
+          description: Type.Optional(Type.String()),
+          items: Type.Array(
+            Type.Object({
+              id: Type.String({
+                title: "Item ID",
+              }),
+              name: Type.String({
+                title: "Item Name",
+              }),
+              description: Type.String({
+                title: "Item Description",
+              }),
+              price: Type.Number({
+                title: "Price",
+                minimum: 0,
+              }),
+              currency: Type.String({
+                default: "USD",
+              }),
+              spicyLevel: Type.Optional(
+                Type.Number({
+                  minimum: 0,
+                  maximum: 5,
+                }),
+              ),
+              allergens: Type.Optional(
+                Type.Array(
+                  Type.String({
+                    enum: ["Gluten", "Dairy", "Nuts", "Eggs", "Soy", "Shellfish", "Fish", "Other"],
+                  }),
+                ),
+              ),
+              dietary: Type.Optional(
+                Type.Array(
+                  Type.String({
+                    enum: ["Vegetarian", "Vegan", "Halal", "Kosher", "Gluten-Free", "Dairy-Free"],
+                  }),
+                ),
+              ),
+              available: Type.Boolean({
+                title: "Currently Available",
+                default: true,
+              }),
+              image: Type.Optional(
+                Type.String({
+                  title: "Image URL",
+                  pattern: "^https?://.*",
+                }),
+              ),
+              customizations: Type.Optional(
+                Type.Array(
+                  Type.Object({
+                    name: Type.String({
+                      title: "Customization Name",
+                    }),
+                    options: Type.Array(
+                      Type.Object({
+                        name: Type.String(),
+                        price: Type.Optional(Type.Number()),
+                      }),
+                    ),
+                    required: Type.Boolean({
+                      default: false,
+                    }),
+                    multiSelect: Type.Boolean({
+                      default: false,
+                    }),
+                  }),
+                ),
+              ),
+            }),
+          ),
+        }),
+      ),
+      specials: Type.Optional(
+        Type.Array(
+          Type.Object({
+            name: Type.String(),
+            description: Type.String(),
+            price: Type.Number(),
+            startDate: Type.String({
+              format: "date",
+            }),
+            endDate: Type.String({
+              format: "date",
+            }),
+            daysAvailable: Type.Optional(
+              Type.Array(
+                Type.String({
+                  enum: ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"],
+                }),
+              ),
+            ),
+          }),
+        ),
+      ),
+    }),
+  },
+  {
+    description: "Schema representing a restaurant with its menu and details",
+  },
+);

package/src/shared/datasources/samples.ts

@@ -0,0 +1,26 @@
+import type { TSchema, Static } from "@sinclair/typebox";
+import { sample as rssSample } from "./external/rss/sample";
+import { sample as youtubeListSample } from "./external/youtube/list/sample";
+import type { DatasourceProvider } from "./types";
+
+export const samples: Record<
+  Extract<
+    DatasourceProvider,
+    // | "facebook-posts"
+    // | "instagram-feed"
+    | "rss"
+    // | "threads-media"
+    // | "tiktok-video"
+    | "youtube-list"
+    // | "mastodon-status"
+  >,
+  Static<TSchema>
+> = {
+  // "facebook-posts": facebookListSample,
+  // "instagram-feed": instagramFeedSample,
+  // "mastodon-status": mastodonStatusSample,
+  rss: rssSample,
+  // "threads-media": threadsMediaSample,
+  // "tiktok-video": tiktokVideoSample,
+  "youtube-list": youtubeListSample,
+} as const;

package/src/shared/datasources/schemas.ts

@@ -0,0 +1,48 @@
+import type { TArray, TObject } from "@sinclair/typebox";
+import type { DatasourceProvider } from "./types";
+
+import { facebookPostSchema } from "./external/facebook/posts/schema";
+import { instagramFeedSchema } from "./external/instagram/feed/schema";
+import { mastodonStatusArraySchema, mastodonStatusSchema } from "./external/mastodon/status/schema";
+import { mastodonAccountSchema } from "./external/mastodon/account/schema";
+import { rssSchema } from "./external/rss/schema";
+import { threadsMediaSchema } from "./external/threads/media/schema";
+import { tiktokVideoListSchema } from "./external/tiktok/video/schema";
+import { youtubeListSchema } from "./external/youtube/list/schema";
+import { jsonArraySchema, jsonObjectSchema } from "./external/http-json/schema";
+
+// internal
+import { blogSchema } from "./internal/blog/schema";
+import { changelogSchema } from "./internal/changelog/schema";
+import { contactInfoSchema } from "./internal/contact-info/schema";
+import { cvSchema } from "./internal/cv/schema";
+import { faqSchema } from "./internal/faq/schema";
+import { linksSchema } from "./internal/links/schema";
+import { recipesSchema } from "./internal/recipes/schema";
+import { restaurantSchema } from "./internal/restaurant/schema";
+
+export const schemasMap = {
+  // "facebook-posts": facebookPostSchema,
+  // "instagram-feed": instagramFeedSchema,
+  // "mastodon-account": mastodonAccountSchema,
+  // "mastodon-status": mastodonStatusSchema,
+  // "mastodon-status-list": mastodonStatusArraySchema,
+  rss: rssSchema,
+  // "threads-media": threadsMediaSchema,
+  // "tiktok-video": tiktokVideoListSchema,
+  "youtube-list": youtubeListSchema,
+  // "internal-blog": blogSchema,
+  // "internal-changelog": changelogSchema,
+  // "internal-contact-info": contactInfoSchema,
+  // "internal-faq": faqSchema,
+  // "internal-links": linksSchema,
+  // "internal-recipes": recipesSchema,
+  // "internal-restaurant": restaurantSchema,
+  // "internal-cv": cvSchema,
+  "http-json": {
+    description: "JSON array retrieved from an HTTP endpoint",
+  },
+} as const satisfies Record<
+  Exclude<DatasourceProvider, "internal">,
+  TArray | TArray[] | { description: string }
+>;