@oatfi/oatfi-sdk-ts 0.11.62 → 0.11.64

package/src/types/primitives.ts

@@ -0,0 +1,148 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { defaultToZeroValue } from "./defaultToZeroValue.js";
+import { unrecognized } from "./unrecognized.js";
+
+export function string(): z.ZodType<string, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.string(),
+
+    // Null or undefined -> ""
+    zodDefaultToZeroValue(""),
+
+    // Any other value -> String(x)
+    z.any().transform((x) => unrecognized(JSON.stringify(x))),
+  ]);
+}
+
+export function boolean(): z.ZodType<boolean, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.boolean(),
+
+    // String "true" (case insensitive) -> true, "false" -> false
+    z.string().transform((x, ctx) => {
+      const lower = x.toLowerCase();
+      if (lower === "true") return unrecognized(true);
+      if (lower === "false") return unrecognized(false);
+      ctx.addIssue({
+        code: "invalid_type",
+        expected: "boolean",
+        received: "string",
+      });
+      return z.NEVER;
+    }),
+
+    zodDefaultToZeroValue(false),
+  ]);
+}
+
+export function number(): z.ZodType<number, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.number(),
+
+    // String -> Number
+    z.string().transform((x, ctx) => {
+      const num = Number(x);
+      if (isNaN(num)) {
+        ctx.addIssue({
+          code: "invalid_type",
+          expected: "number",
+          received: "string",
+        });
+        return z.NEVER;
+      }
+      return unrecognized(num);
+    }),
+
+    // Null or undefined -> 0
+    zodDefaultToZeroValue(0),
+  ]);
+}
+
+export function bigint(): z.ZodType<bigint, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.string().transform((x, ctx) => {
+      try {
+        return BigInt(x);
+      } catch (error) {
+        ctx.addIssue({
+          code: "invalid_type",
+          expected: "bigint",
+          received: "string",
+        });
+        return z.NEVER;
+      }
+    }),
+    zodDefaultToZeroValue(0n),
+  ]);
+}
+
+export function date(): z.ZodType<Date, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.union([z.string(), zodDefaultToZeroValue(0)]).transform((x) =>
+      new Date(x)
+    ).pipe(z.date()),
+    z.number().transform((x, ctx) => {
+      const date = new Date(x);
+      if (isNaN(date.getTime())) {
+        ctx.addIssue({
+          code: "invalid_type",
+          expected: "date",
+          received: "number",
+        });
+        return z.NEVER;
+      }
+      return unrecognized(date);
+    }),
+  ]);
+}
+
+export function literal<T extends string | number | boolean>(
+  value: T,
+): z.ZodType<T, z.ZodTypeDef, unknown> {
+  return z.union([z.literal(value), zodDefaultToZeroValue(value)]);
+}
+
+export function literalBigInt<T extends bigint>(
+  value: T,
+): z.ZodType<T, z.ZodTypeDef, unknown> {
+  return z.literal(String(value)).transform((x) => BigInt(x)) as any;
+}
+
+export function optional<T extends z.ZodType>(t: T) {
+  return z.union([
+    z.undefined(),
+
+    // Null -> undefined
+    z.null().transform(() => unrecognized(undefined)),
+    t,
+  ]);
+}
+
+export function nullable<T extends z.ZodType>(t: T) {
+  return z.union([
+    z.null(),
+
+    // Undefined -> null
+    z.undefined().transform(() => defaultToZeroValue(null)),
+    t,
+  ]);
+}
+
+function zodDefaultToZeroValue<T>(
+  value: T,
+): z.ZodType<T, z.ZodTypeDef, unknown> {
+  return z.any().transform((input, ctx) => {
+    if (input === undefined) return defaultToZeroValue(value);
+    if (input === null) return defaultToZeroValue(value);
+    ctx.addIssue({
+      code: "invalid_type",
+      expected: "undefined",
+      received: "unknown",
+    });
+    return z.NEVER;
+  });
+}

package/src/types/smartUnion.ts

@@ -0,0 +1,153 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+// Not needed if lax mode
+import * as z from "zod/v3";
+import { startCountingDefaultToZeroValue } from "./defaultToZeroValue.js";
+import { RFCDate } from "./rfcdate.js";
+import { startCountingUnrecognized } from "./unrecognized.js";
+
+interface Candidate {
+  data: unknown;
+  /** Total number of fields in the parsed data */
+  fieldCount: number;
+  /** Number of fields which only matched due to lax parsing */
+  inexactCount: number;
+  /** Number of fields which defaulted to zero values */
+  zeroDefaultCount: number;
+}
+
+/**
+ * Smart union parser that tries all schemas and returns the best match
+ * based on the number of populated fields.
+ */
+export function smartUnion<
+  Options extends readonly [z.ZodType, z.ZodType, ...z.ZodType[]],
+>(
+  options: Options,
+): z.ZodType<
+  z.output<Options[number]>,
+  z.ZodTypeDef,
+  z.input<Options[number]>
+> {
+  return z.unknown().transform((input, ctx) => {
+    const candidates: Candidate[] = [];
+    const errors: z.ZodIssue[][] = options.map(() => []);
+
+    const parentUnrecognizedCtr = startCountingUnrecognized();
+    const parentZeroDefaultCtr = startCountingDefaultToZeroValue();
+
+    // Filter out invalid options
+    for (const [i, option] of options.entries()) {
+      const unrecognizedCtr = startCountingUnrecognized();
+      const zeroDefaultCtr = startCountingDefaultToZeroValue();
+      const result = option.safeParse(input);
+      const inexactCount = unrecognizedCtr.end();
+      const zeroDefaultCount = zeroDefaultCtr.end();
+      if (result.success) {
+        candidates.push({
+          data: result.data,
+          inexactCount,
+          zeroDefaultCount,
+          fieldCount: -1, // We'll count this later if needed
+        });
+        continue;
+      }
+      errors[i]!.push(...result.error.issues);
+    }
+
+    // No valid options
+    if (candidates.length === 0) {
+      parentUnrecognizedCtr.end(0);
+      parentZeroDefaultCtr.end(0);
+      ctx.addIssue({
+        code: "invalid_union",
+        unionErrors: errors.map(issues => new z.ZodError(issues)),
+      });
+      return z.NEVER;
+    }
+
+    let best = candidates[0]!;
+
+    // Find the best option
+    for (const candidate of candidates) {
+      // Minor optimization to avoid counting fields if there's only one candidate
+      if (candidates.length > 1) {
+        candidate.fieldCount = countFieldsRecursive(candidate.data);
+      }
+      best = better(candidate, best);
+    }
+
+    // The cost of this union should be the cost of the best candidate not all the candidates
+    parentUnrecognizedCtr.end(best.inexactCount);
+    parentZeroDefaultCtr.end(best.zeroDefaultCount);
+
+    return best.data;
+  }) as any;
+}
+
+function better(a: Candidate, b: Candidate): Candidate {
+  // First prefer exact matches over inexact ones
+  const aIsExact = a.inexactCount === 0;
+  const bIsExact = b.inexactCount === 0;
+  if (aIsExact !== bIsExact) {
+    return aIsExact ? a : b;
+  }
+
+  // Then compare field counts
+  const actualFieldCountA = a.fieldCount - a.zeroDefaultCount;
+  const actualFieldCountB = b.fieldCount - b.zeroDefaultCount;
+  if (actualFieldCountA !== actualFieldCountB) {
+    return actualFieldCountA > actualFieldCountB ? a : b;
+  }
+  return a.inexactCount < b.inexactCount ? a : b;
+}
+
+/**
+ * Counts the number of fields in a parsed value recursively.
+ * @param `parsed` assumed to *not* contain cycles
+ * fieldCount: total number of fields found
+ * inexactCount: number of primitive values that are not unrecognized enum values
+ */
+function countFieldsRecursive(parsed: unknown): number {
+  let fieldCount = 0;
+
+  const queue: unknown[] = [parsed];
+  let index = 0;
+
+  while (index < queue.length) {
+    const value = queue[index++];
+    if (value === undefined) {
+      continue;
+    }
+
+    // Check if it's a primitive value
+    const type = typeof value;
+    if (
+      value === null
+      || type === "number"
+      || type === "string"
+      || type === "boolean"
+      || type === "bigint"
+      || value instanceof Date
+      || value instanceof RFCDate
+    ) {
+      fieldCount++;
+      continue;
+    }
+
+    // Handle arrays
+    if (Array.isArray(value)) {
+      queue.push(...value);
+      continue;
+    }
+
+    // Handle objects
+    if (type === "object") {
+      queue.push(...Object.values(value));
+    }
+  }
+
+  return fieldCount;
+}