@upstart.gg/sdk 0.0.136 → 0.0.137

package/src/shared/utils/schema.ts

@@ -1,8 +1,53 @@
 import { type TArray, type TObject, type TSchema, Kind, type Static } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
 import type { PageAttributes } from "../attributes";
-import { schemaRegistry } from "./schema-registry";
-import { Cabidela } from "@cloudflare/cabidela";
-import { defaultsDeep as applyDefaultsDeep } from "lodash-es";
+import { defaultsDeep as applyDefaultsDeep, merge } from "lodash-es";
+import { FormatRegistry } from "@sinclair/typebox";
+import { DefaultErrorFunction, SetErrorFunction, ValueErrorType } from "@sinclair/typebox/errors";
+// export const jsonStringsSupportedFormats = ["date-time", "date", "email", "url"] as const;
+
+// import string enum for its side effects
+import "./string-enum";
+
+const urlValidator = (value: string) => {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+
+const noCheck = (value: string) => true;
+
+FormatRegistry.Set("uuid", (value) =>
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value),
+);
+// Allow different lengths for nanoid
+FormatRegistry.Set("nanoid", (value) => /^[A-Za-z0-9_-]{7,32}$/.test(value));
+FormatRegistry.Set("slug", (value) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value));
+// Simple format checks for richtext, markdown, multiline, password, image, file
+FormatRegistry.Set("richtext", noCheck);
+FormatRegistry.Set("markdown", noCheck);
+FormatRegistry.Set("multiline", noCheck);
+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)) {
@@ -24,11 +69,11 @@ export function normalizeSchemaEnum(schema: TSchema): Array<{ const: string; tit
 export function getSchemaDefaults<T extends TObject | TArray>(
   schema: T,
   mode?: "mobile" | "desktop",
-): T extends TObject ? Record<string, unknown> : unknown[] {
+): Static<T> {
   // Handle object schemas
   if (schema.type === "object" && "properties" in schema) {
     const objectSchema = schema as TObject;
-    const defaults: Record<string, unknown> = {};
+    const defaults: Static<T> = {};
 
     for (const [key, propertySchema] of Object.entries(objectSchema.properties)) {
       const defaultValue = getNestedDefaults(propertySchema as TSchema, mode);
@@ -39,8 +84,7 @@ export function getSchemaDefaults<T extends TObject | TArray>(
       }
     }
 
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    return defaults as any;
+    return defaults as Static<T>;
   }
 
   // Handle array schemas
@@ -48,19 +92,16 @@ export function getSchemaDefaults<T extends TObject | TArray>(
     const arraySchema = schema as TArray;
 
     if (mode && typeof arraySchema[`default:${mode}`] !== "undefined") {
-      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-      return arraySchema[`default:${mode}`] as any;
+      return arraySchema[`default:${mode}`];
     }
 
     // If the array itself has an explicit default, return it
     if (arraySchema.default) {
-      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-      return arraySchema.default as any;
+      return arraySchema.default;
     }
 
     // Otherwise return empty array
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    return [] as any;
+    return [];
   }
 
   throw new Error("Schema must be either TObject or TArray");
@@ -131,244 +172,30 @@ export function filterSchemaProperties(schema: TObject, filter: (prop: TSchema)
  * Handles nested objects, arrays, and complex schema structures.
  */
 export function resolveSchema<T extends TSchema = TSchema>(schema: T): T {
-  return resolveSchemaRecursive(schema, new Set()) as T;
+  console.warn("resolveSchema is deprecated, use resolveSchemaRecursive instead");
+  return schema;
 }
 
-/**
- * Internal recursive function with circular reference detection
- */
-function resolveSchemaRecursive(schema: TSchema, visited: Set<string>): TSchema {
-  // Handle primitive types and null
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-
-  // Handle $ref resolution
-  if ("$ref" in schema && typeof schema.$ref === "string") {
-    // Prevent infinite recursion with circular references
-    if (visited.has(schema.$ref) || schema[Kind] === "This") {
-      // console.warn(`Circular reference detected: ${schema.$ref}`);
-      return schema; // Return original schema to avoid infinite loop
-    }
-
-    const resolved = schemaRegistry.get(schema.$ref);
-    if (!resolved) {
-      console.error("Schema not found for reference:", schema);
-      return schema;
-    }
-
-    // Add to visited set and recursively resolve the referenced schema
-    visited.add(schema.$ref);
-    const { $ref, ...rest } = schema;
-    const resolvedSchema = {
-      ...resolveSchemaRecursive(resolved, visited),
-      ...rest,
-    };
-    visited.delete(schema.$ref); // Remove from visited after processing
-
-    return resolvedSchema as TSchema;
-  }
-
-  // Handle object schemas
-  if ("type" in schema && schema.type === "object" && "properties" in schema) {
-    const resolvedProperties: Record<string, TSchema> = {};
-
-    if (schema.properties && typeof schema.properties === "object") {
-      for (const [key, value] of Object.entries(schema.properties)) {
-        if (value && typeof value === "object") {
-          resolvedProperties[key] = resolveSchemaRecursive(value as TSchema, visited);
-        } else {
-          resolvedProperties[key] = value as TSchema;
-        }
-      }
-    }
-
-    const resolvedSchema = { ...schema };
-    if (Object.keys(resolvedProperties).length > 0) {
-      resolvedSchema.properties = resolvedProperties;
-    }
-
-    // Handle additionalProperties
-    if (
-      "additionalProperties" in schema &&
-      schema.additionalProperties &&
-      typeof schema.additionalProperties === "object" &&
-      schema.additionalProperties !== true
-    ) {
-      resolvedSchema.additionalProperties = resolveSchemaRecursive(
-        schema.additionalProperties as TSchema,
-        visited,
-      );
-    }
-
-    // Handle patternProperties
-    if (
-      "patternProperties" in schema &&
-      schema.patternProperties &&
-      typeof schema.patternProperties === "object"
-    ) {
-      const resolvedPatternProperties: Record<string, TSchema> = {};
-      for (const [pattern, patternSchema] of Object.entries(schema.patternProperties)) {
-        if (patternSchema && typeof patternSchema === "object") {
-          resolvedPatternProperties[pattern] = resolveSchemaRecursive(patternSchema as TSchema, visited);
-        } else {
-          resolvedPatternProperties[pattern] = patternSchema as TSchema;
-        }
-      }
-      resolvedSchema.patternProperties = resolvedPatternProperties;
-    }
-
-    return resolvedSchema as TSchema;
-  }
-
-  // Handle array schemas
-  if ("type" in schema && schema.type === "array") {
-    const resolvedSchema = { ...schema };
-
-    if ("items" in schema && schema.items) {
-      if (Array.isArray(schema.items)) {
-        resolvedSchema.items = schema.items.map((item) => resolveSchemaRecursive(item as TSchema, visited));
-      } else if (typeof schema.items === "object") {
-        resolvedSchema.items = resolveSchemaRecursive(schema.items as TSchema, visited);
-      }
-    }
-
-    // Handle additionalItems
-    if (
-      "additionalItems" in schema &&
-      schema.additionalItems &&
-      typeof schema.additionalItems === "object" &&
-      schema.additionalItems !== true
-    ) {
-      resolvedSchema.additionalItems = resolveSchemaRecursive(schema.additionalItems as TSchema, visited);
-    }
-
-    return resolvedSchema as TSchema;
-  }
-
-  // Handle union schemas (anyOf)
-  if ("anyOf" in schema && Array.isArray(schema.anyOf)) {
-    const resolvedAnyOf = schema.anyOf.map((subSchema) => {
-      return resolveSchemaRecursive(subSchema as TSchema, visited);
-    });
-
-    return { ...schema, anyOf: resolvedAnyOf } as TSchema;
-  }
-
-  // Handle union schemas (oneOf)
-  if ("oneOf" in schema && Array.isArray(schema.oneOf)) {
-    const resolvedOneOf = schema.oneOf.map((subSchema) =>
-      resolveSchemaRecursive(subSchema as TSchema, visited),
-    );
-
-    return { ...schema, oneOf: resolvedOneOf } as TSchema;
-  }
-
-  // Handle intersection schemas (allOf)
-  if ("allOf" in schema && Array.isArray(schema.allOf)) {
-    const resolvedAllOf = schema.allOf.map((subSchema) =>
-      resolveSchemaRecursive(subSchema as TSchema, visited),
-    );
-
-    return { ...schema, allOf: resolvedAllOf } as TSchema;
-  }
-
-  // Handle not schemas
-  if ("not" in schema && schema.not && typeof schema.not === "object") {
-    const resolvedNot = resolveSchemaRecursive(schema.not as TSchema, visited);
-
-    return { ...schema, not: resolvedNot } as TSchema;
-  }
-
-  // Handle conditional schemas (if/then/else)
-  if ("if" in schema || "then" in schema || "else" in schema) {
-    const resolvedSchema = { ...schema };
-
-    if ("if" in schema && schema.if && typeof schema.if === "object") {
-      resolvedSchema.if = resolveSchemaRecursive(schema.if as TSchema, visited);
-    }
-
-    if ("then" in schema && schema.then && typeof schema.then === "object") {
-      // biome-ignore lint/suspicious/noThenProperty: <explanation>
-      resolvedSchema.then = resolveSchemaRecursive(schema.then as TSchema, visited);
-    }
-
-    if ("else" in schema && schema.else && typeof schema.else === "object") {
-      resolvedSchema.else = resolveSchemaRecursive(schema.else as TSchema, visited);
-    }
-
-    return resolvedSchema as TSchema;
-  }
-
-  // Handle schemas with definitions
-  if ("definitions" in schema || "$defs" in schema) {
-    const resolvedSchema = { ...schema };
-
-    if ("definitions" in schema && schema.definitions && typeof schema.definitions === "object") {
-      const resolvedDefinitions: Record<string, TSchema> = {};
-      for (const [key, def] of Object.entries(schema.definitions)) {
-        if (def && typeof def === "object") {
-          resolvedDefinitions[key] = resolveSchemaRecursive(def as TSchema, visited);
-        } else {
-          resolvedDefinitions[key] = def as TSchema;
-        }
+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`;
       }
-      resolvedSchema.definitions = resolvedDefinitions;
+      console.error("Validation errors:\n", finalError);
+      throw new Error(finalError);
     }
-
-    if ("$defs" in schema && schema.$defs && typeof schema.$defs === "object") {
-      const resolved$Defs: Record<string, TSchema> = {};
-      for (const [key, def] of Object.entries(schema.$defs)) {
-        if (def && typeof def === "object") {
-          resolved$Defs[key] = resolveSchemaRecursive(def as TSchema, visited);
-        } else {
-          resolved$Defs[key] = def as TSchema;
-        }
-      }
-      resolvedSchema.$defs = resolved$Defs;
-    }
-
-    return resolvedSchema as TSchema;
+  } catch (e) {
+    console.error("Validation exception:", e);
+    console.dir(e, { depth: null });
+    throw e;
   }
 
-  // Handle any other schema types that might contain nested schemas
-  const resolvedSchema = { ...schema };
-
-  for (const [key, value] of Object.entries(schema)) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      // Check if this looks like a schema object
-      if ("type" in value || "$ref" in value || "properties" in value || "items" in value) {
-        (resolvedSchema as Record<string, unknown>)[key] = resolveSchemaRecursive(value as TSchema, visited);
-      }
-    } else if (Array.isArray(value)) {
-      // Check if array contains schemas
-      const hasSchemas = value.some(
-        (item) =>
-          item &&
-          typeof item === "object" &&
-          ("type" in item || "$ref" in item || "properties" in item || "items" in item),
-      );
-
-      if (hasSchemas) {
-        (resolvedSchema as Record<string, unknown>)[key] = value.map((item) =>
-          item && typeof item === "object" ? resolveSchemaRecursive(item as TSchema, visited) : item,
-        );
-      }
-    }
-  }
-
-  return resolvedSchema as TSchema;
-}
-
-export function validate<T extends TSchema>(schema: TSchema, data: unknown): data is Static<T> {
-  const validator = new Cabidela(schema, {
-    fullErrors: true,
-  });
-  validator.validate(data);
-
   // Mutate data with defaults
   const defaults = getSchemaDefaults(schema as TObject | TArray);
-  applyDefaultsDeep(data, defaults);
+  const finalObject = applyDefaultsDeep({}, data, defaults);
 
-  return true;
+  return finalObject as Static<T>;
 }

package/src/shared/utils/string-enum.ts

@@ -1,12 +1,33 @@
-import { Type, type UnsafeOptions } from "@sinclair/typebox";
+import { TypeRegistry, Kind, type TSchema, type SchemaOptions, Type } from "@sinclair/typebox";
 
-export type StringEnumOptions = Partial<UnsafeOptions> & {
+export type StringEnumOptions = Partial<SchemaOptions> & {
   enumNames?: string[];
 };
 
-export const StringEnum = <T extends string[]>(values: [...T], options: StringEnumOptions = {}) =>
-  Type.Unsafe<T[number]>({
+// -------------------------------------------------------------------------------------
+// TStringEnum
+// -------------------------------------------------------------------------------------
+export interface TStringEnum<T extends string[]> extends TSchema {
+  [Kind]: "StringEnum";
+  static: T[number];
+  enum: T;
+}
+
+function StringEnumCheck(schema: TStringEnum<string[]>, value: unknown) {
+  return typeof value === "string" && schema.enum.includes(value);
+}
+
+TypeRegistry.Set("StringEnum", StringEnumCheck);
+
+// -------------------------------------------------------------------------------------
+// UnionEnum
+// -------------------------------------------------------------------------------------
+/** `[Experimental]` Creates a Union type with a `enum` schema representation  */
+export function StringEnum<T extends string[]>(values: [...T], options: StringEnumOptions = {}) {
+  return Type.Unsafe<T[number]>({
+    [Kind]: "StringEnum",
     type: "string",
     enum: values,
     ...options,
   });
+}