rafay-test-ts-gm 1.22.5

package/src/core/response-error.ts

@@ -0,0 +1,86 @@
+import { decodeResponse, type AnyResponseDecoder, type ResponseDecoder } from "./response-decoder.js";
+import { CoreError, ConnectionError } from "./errors.js";
+
+export type Declared<K extends string, B> = {
+  readonly kind: K;
+  readonly body: B;
+};
+
+export type Undeclared = {
+  readonly kind: "undeclared";
+  readonly rawBody: ArrayBuffer;
+};
+
+export type ErrorPayload<P = never> = P | Undeclared;
+
+export type AnyPayload = ErrorPayload<Declared<string, unknown>>;
+
+export type ResponseErrorInit<Payload = Undeclared> = {
+  status: number;
+  headers: Headers;
+  message: string;
+  payload: Payload;
+};
+
+export class ResponseError<P = Undeclared> extends Error {
+  readonly status: number;
+  readonly headers: Headers;
+  readonly payload: ErrorPayload<P>;
+
+  constructor(init: ResponseErrorInit<ErrorPayload<P>>) {
+    super(init.message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.status = init.status;
+    this.headers = init.headers;
+    this.payload = init.payload;
+  }
+}
+
+export type StatusPattern = number | "1XX" | "2XX" | "3XX" | "4XX" | "5XX" | readonly [number, number];
+
+export type AnyResponseError = ResponseError<unknown>;
+
+export type PayloadOf<E extends AnyResponseError> = E["payload"];
+
+type AnyMatcher = { readonly on: StatusPattern; readonly kind: string; readonly decode: AnyResponseDecoder };
+
+type ErrorMatcher<D> = D extends { kind: infer K extends string; body: infer B }
+  ? { readonly on: StatusPattern; readonly kind: K; readonly decode: ResponseDecoder<B> }
+  : never;
+
+export type ErrorDecoders<E extends AnyResponseError> = readonly ErrorMatcher<PayloadOf<E>>[];
+
+export type ErrorFactory<E extends AnyResponseError> = (new (init: ResponseErrorInit<PayloadOf<E>>) => E) & {
+  readonly errors?: ErrorDecoders<E> | undefined;
+};
+
+export type ResponseHandler<T = unknown, E extends AnyResponseError = AnyResponseError> = {
+  success: ResponseDecoder<T>;
+  errorFactory: ErrorFactory<E>;
+};
+
+export async function decodeErrorPayload(
+  response: Response,
+  matchers: readonly AnyMatcher[] | undefined,
+  status: number,
+): Promise<AnyPayload> {
+  const matcher =
+    matchers?.find((m) => m.on === status) ??
+    matchers?.find((m) => typeof m.on !== "number" && matchesStatus(m.on, status));
+
+  if (matcher) return { kind: matcher.kind, body: await decodeResponse(matcher.decode, response) };
+
+  try {
+    return { kind: "undeclared", rawBody: await response.arrayBuffer() };
+  } catch (err) {
+    if (err instanceof CoreError) throw err;
+    throw new ConnectionError({ message: "Response body could not be read.", cause: err });
+  }
+}
+
+function matchesStatus(pattern: StatusPattern, status: number): boolean {
+  if (typeof pattern === "number") return pattern === status;
+  if (typeof pattern === "string") return `${Math.floor(status / 100)}XX` === pattern;
+  return status >= pattern[0] && status <= pattern[1];
+}

package/src/core/url.ts

@@ -0,0 +1,58 @@
+import type { UrlTemplate } from "./api-request.js";
+import type { StyledParam, Param } from "./param-value.js";
+import { encodedParam, flattenValue } from "./param-value.js";
+import { percentEncode, queryString } from "./params.js";
+import { SdkError } from "./errors.js";
+
+export function buildUrl(
+  template: UrlTemplate,
+  pathParams: readonly Param[] | undefined,
+  query: readonly StyledParam[] | undefined,
+  defaultQuery: readonly StyledParam[],
+  defaultPathParams?: readonly Param[],
+  authQuery?: readonly StyledParam[],
+): URL {
+  const resolvedBase = expandVariables(template.baseUrl, template.variables);
+  const path = expandPath(template.subPath, pathParams, defaultPathParams);
+  const url = new URL(joinUrl(resolvedBase, path));
+  const search = queryString([defaultQuery, query, authQuery], [...url.searchParams]);
+  if (search) url.search = search;
+  return url;
+}
+
+function expandVariables(template: string, variables: Record<string, string> | undefined): string {
+  let out = template;
+  for (const [key, value] of Object.entries(variables ?? {})) {
+    out = out.replaceAll(`{${key}}`, percentEncode(value));
+  }
+  return out;
+}
+
+function expandPath(template: string, ...layers: ReadonlyArray<readonly Param[] | undefined>): string {
+  let out = template;
+  const skipped: string[] = [];
+  for (const layer of layers) {
+    for (const source of layer ?? []) {
+      const value = encodedParam(source);
+      if (value === undefined) {
+        skipped.push(source.name);
+        continue;
+      }
+      const replacement = value === null ? "" : flattenValue(value).map(percentEncode).join(",");
+      out = out.replaceAll(`{${source.name}}`, replacement);
+    }
+  }
+  for (const name of skipped) {
+    if (!out.includes(`{${name}}`)) continue;
+    throw new SdkError({
+      message: `Path parameter "${name}" resolved to undefined and left {${name}} unfilled.`,
+    });
+  }
+  return out;
+}
+
+function joinUrl(base: string, path: string): string {
+  const left = base.replace(/\/+$/, "");
+  const right = path.replace(/^\/+/, "");
+  return `${left}/${right}`;
+}

package/src/core/validation/entries.ts

@@ -0,0 +1,66 @@
+import * as zod from "zod/v4-mini";
+import type { ZodMiniType } from "zod/v4-mini";
+import { resolve, type Encoded, type Entry, type Schema } from "./schema.js";
+
+export function lazy<T>(target: () => Schema<T, Encoded<T>>): ZodMiniType<T, Encoded<T>> {
+  return zod.lazy(() => resolve(target()));
+}
+
+export function defaulted<T>(entry: Entry<T, Encoded<T>>, value: T): ZodMiniType<T, Encoded<T>> {
+  return zod.codec(zod.optional(resolve(entry)), zod.custom<T>(), {
+    decode: (given: T | undefined) => (given === undefined ? value : given),
+    encode: (given: T | undefined) => (given === undefined ? value : given),
+  }) as unknown as ZodMiniType<T, Encoded<T>>;
+}
+
+export function optionalNullable<T>(
+  entry: Entry<T, Encoded<T>>,
+): ZodMiniType<T | null | undefined, Encoded<T> | null | undefined> {
+  return zod.optional(zod.nullable(resolve(entry)));
+}
+
+export const dateTime = (): ZodMiniType<Date, string> =>
+  zod.codec(zod.iso.datetime({ offset: true }), zod.date(), {
+    decode: (value) => new Date(value),
+    encode: (date) => date.toISOString(),
+  });
+
+const IMF_FIXDATE =
+  /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT$/;
+
+export const rfc1123DateTime = (): ZodMiniType<Date, string> =>
+  zod.codec(zod.string().check(zod.regex(IMF_FIXDATE)), zod.date(), {
+    decode: (value) => new Date(value),
+    encode: (date) => date.toUTCString(),
+  });
+
+const EPOCH_SECONDS = /^-?\d+(?:\.\d+)?$/;
+
+export const unixSecondsDateTime = (): ZodMiniType<Date, number> =>
+  zod.codec(zod.union([zod.number(), zod.string().check(zod.regex(EPOCH_SECONDS))]), zod.date(), {
+    decode: (value) => new Date(Number(value) * 1000),
+    encode: (date) => Math.floor(date.getTime() / 1000),
+  }) as unknown as ZodMiniType<Date, number>;
+
+export const dateOnly = (): ZodMiniType<string, string> => zod.iso.date();
+
+const BYTES = zod.custom<Uint8Array>((value) => value instanceof Uint8Array);
+
+export const bytes = (): ZodMiniType<Uint8Array, string> =>
+  zod.codec(zod.base64(), BYTES, {
+    decode: (value) => decodeBase64(value),
+    encode: (value) => encodeBase64(value),
+  });
+
+function decodeBase64(value: string): Uint8Array {
+  const latin1 = atob(value);
+  const bytes = new Uint8Array(latin1.length);
+  for (let index = 0; index < latin1.length; index++) bytes[index] = latin1.charCodeAt(index);
+  return bytes;
+}
+
+function encodeBase64(value: Uint8Array): string {
+  let latin1 = "";
+  for (const byte of value) latin1 += String.fromCharCode(byte);
+  return btoa(latin1);
+}

package/src/core/validation/index.ts

@@ -0,0 +1,23 @@
+export {
+  array,
+  boolean,
+  literal,
+  nullable,
+  number,
+  optional,
+  record,
+  string,
+  union,
+  unknown,
+} from "zod/v4-mini";
+export {
+  lazy,
+  optionalNullable,
+  defaulted,
+  dateTime,
+  rfc1123DateTime,
+  unixSecondsDateTime,
+  dateOnly,
+  bytes,
+} from "./entries.js";
+export { object, discriminatedUnion, enumOf, of } from "./schema.js";

package/src/core/validation/schema-error.ts

@@ -0,0 +1,102 @@
+import * as schema from "zod/v4-mini";
+import type { ZodMiniType } from "zod/v4-mini";
+import { CoreError } from "../errors.js";
+import type { Entry, Schema } from "./schema.js";
+
+export type SchemaErrorInit = {
+  message: string;
+  rawBody?: unknown;
+  cause?: unknown;
+};
+
+export class SchemaError extends CoreError {
+  readonly kind = "schema" as const;
+  readonly rawBody: unknown;
+
+  constructor(init: SchemaErrorInit) {
+    super(init.message, init.cause !== undefined ? { cause: init.cause } : undefined);
+    this.rawBody = init.rawBody;
+  }
+}
+
+export function decodeWith<T>(zodType: ZodMiniType<T, unknown>, value: unknown): T {
+  const result = zodType.safeParse(value);
+  if (result.success) return result.data;
+  throw new SchemaError({
+    message: issuesMessage(result.error, value),
+    rawBody: value,
+    cause: result.error,
+  });
+}
+
+export function encodeWith<T, W>(zodType: ZodMiniType<T, W>, value: unknown): W {
+  const result = schema.safeEncode(zodType, value as T);
+  if (result.success) return result.data;
+  throw new SchemaError({
+    message: issuesMessage(result.error, value, "Type could not be encoded for the wire."),
+    rawBody: value,
+    cause: result.error,
+  });
+}
+
+export function decodeEntry<V>(schema: Entry<V>, value: unknown): V {
+  return isSchemaEntry(schema) ? schema.decode(value) : decodeWith(schema, value);
+}
+
+export function encodeEntry<V, W>(schema: Entry<V, W>, value: unknown): W {
+  return isSchemaEntry(schema) ? schema.encode(value) : encodeWith(schema, value);
+}
+
+function isSchemaEntry<V, W>(entry: Entry<V, W>): entry is Schema<V, W> {
+  return typeof (entry as { decode?: unknown }).decode === "function";
+}
+
+type SchemaIssue = {
+  readonly path: readonly PropertyKey[];
+  readonly message: string;
+  readonly expected?: string | undefined;
+  readonly format?: string | undefined;
+  readonly options?: readonly unknown[] | undefined;
+};
+
+type SchemaIssues = { readonly issues: readonly SchemaIssue[] };
+
+function issuesMessage(
+  error: SchemaIssues,
+  value: unknown,
+  prefix = "Wire value could not be decoded.",
+): string {
+  const issues = error.issues.map((issue) => {
+    const path = issue.path.map(String).join(".") || "<root>";
+    return `${path}: ${issueReason(issue, valueAt(value, issue.path))}`;
+  });
+  return `${prefix} ${issues.join("; ")}`;
+}
+
+function issueReason(issue: SchemaIssue, actual: unknown): string {
+  if (issue.expected !== undefined) return `expected ${issue.expected}, received ${typeName(actual)}`;
+  if (issue.format !== undefined) return `expected ${issue.format} format, received ${literal(actual)}`;
+  if (issue.options !== undefined) {
+    return `expected one of ${issue.options.map(literal).join(" | ")}, received ${literal(actual)}`;
+  }
+  return issue.message;
+}
+
+function valueAt(value: unknown, path: readonly PropertyKey[]): unknown {
+  let current = value;
+  for (const key of path) {
+    if (current === null || typeof current !== "object") return undefined;
+    current = (current as Record<PropertyKey, unknown>)[key];
+  }
+  return current;
+}
+
+function typeName(value: unknown): string {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+
+function literal(value: unknown): string {
+  return JSON.stringify(value) ?? "undefined";
+}

package/src/core/validation/schema.ts

@@ -0,0 +1,137 @@
+import * as zod from "zod/v4-mini";
+import type { ZodMiniType } from "zod/v4-mini";
+import { decodeWith, encodeWith } from "./schema-error.js";
+
+export type Encoded<T> = T extends Date
+  ? string | number
+  : T extends Uint8Array
+    ? string
+    : T extends string | number | boolean | null | undefined
+      ? T
+      : T extends readonly (infer E)[]
+        ? Encoded<E>[]
+        : T extends object
+          ? { [K in keyof T]: Encoded<T[K]> }
+          : T;
+
+export type KeysMap<T> = { readonly [K in keyof T]?: string };
+
+export type Entry<V, W = unknown> = ZodMiniType<V, W> | Schema<V, W>;
+
+export type Shape<T> = { [K in keyof T]-?: Entry<T[K]> } & { readonly _keysMap?: KeysMap<T> };
+
+export type Schema<T, W = Encoded<T>> = {
+  readonly decode: (value: unknown) => T;
+  readonly encode: (value: unknown) => W;
+};
+
+export type EnumSchema<T> = Schema<T, T> & {
+  readonly values: readonly T[];
+};
+
+type Built<T, W> = Schema<T, W> & {
+  readonly zod: () => ZodMiniType<T, W>;
+  readonly tagged: (discriminator: string, value: string) => ZodMiniType<T, W>;
+};
+
+export function object<T>(shape: Shape<T>): Schema<T, Encoded<T>> {
+  let memo: ZodMiniType<T, Encoded<T>> | undefined;
+  const zodType = (): ZodMiniType<T, Encoded<T>> => (memo ??= buildObject(shape));
+  return {
+    zod: zodType,
+    tagged: (discriminator, value) => buildObject(shape, [discriminator, value]),
+    decode: (value) => decodeWith(zodType(), value),
+    encode: (value) => encodeWith(zodType(), value),
+  } as Built<T, Encoded<T>>;
+}
+
+export function discriminatedUnion<T>(
+  discriminator: string,
+  variants: Readonly<Record<string, Schema<unknown, unknown>>>,
+): Schema<T, Encoded<T>> {
+  let memo: ZodMiniType<T, Encoded<T>> | undefined;
+  const build = (): ZodMiniType<T, Encoded<T>> => {
+    const members = Object.entries(variants).map(([value, variant]) =>
+      built(variant).tagged(discriminator, value),
+    );
+    return zod.discriminatedUnion(discriminator, members as never);
+  };
+  const zodType = (): ZodMiniType<T, Encoded<T>> => (memo ??= build());
+  return {
+    zod: zodType,
+    tagged: () => zodType(),
+    decode: (value) => decodeWith(zodType(), value),
+    encode: (value) => encodeWith(zodType(), value),
+  } as Built<T, Encoded<T>>;
+}
+
+export function enumOf<T extends string | number>(members: Readonly<Record<string, T>>): EnumSchema<T> {
+  const values = Object.values(members);
+  const base: ZodMiniType<unknown, unknown> = values.every((value) => typeof value === "number")
+    ? zod.number()
+    : zod.string();
+  return {
+    ...of(base as ZodMiniType<T, T>),
+    values,
+  };
+}
+
+export function of<T, W = Encoded<T>>(zodType: ZodMiniType<T, W>): Schema<T, W> {
+  return {
+    zod: () => zodType,
+    tagged: () => zodType,
+    decode: (value) => decodeWith(zodType, value),
+    encode: (value) => encodeWith(zodType, value),
+  } as Built<T, W>;
+}
+
+function buildObject<T>(shape: Shape<T>, tag?: readonly [string, string]): ZodMiniType<T, Encoded<T>> {
+  const keysMap = (shape as { _keysMap?: Record<string, string> })._keysMap ?? {};
+  const wire: Record<string, ZodMiniType<unknown, unknown>> = {};
+  const renames: [string, string][] = [];
+
+  for (const [key, entry] of Object.entries(shape)) {
+    if (key === "_keysMap") continue;
+    const wireKey = keysMap[key] ?? key;
+    wire[wireKey] = resolve(entry as Entry<unknown>);
+    if (wireKey !== key) renames.push([wireKey, key]);
+  }
+  if (tag) wire[tag[0]] = zod.literal(tag[1]);
+
+  const object: ZodMiniType<Record<string, unknown>, Record<string, unknown>> = zod.looseObject(wire);
+  const renaming: ZodMiniType<unknown, unknown> =
+    renames.length === 0
+      ? object
+      : zod.codec(object, zod.custom<Record<string, unknown>>(), {
+          decode: (value) => renameKeys(value, renames, "decode"),
+          encode: (value) => renameKeys(value, renames, "encode"),
+        });
+  return renaming as ZodMiniType<T, Encoded<T>>;
+}
+
+function renameKeys(
+  value: Record<string, unknown>,
+  renames: readonly [string, string][],
+  direction: "decode" | "encode",
+): Record<string, unknown> {
+  const out = { ...value };
+  for (const [wireKey, key] of renames) {
+    const [from, to] = direction === "decode" ? [wireKey, key] : [key, wireKey];
+    if (!(from in out)) continue;
+    out[to] = out[from];
+    delete out[from];
+  }
+  return out;
+}
+
+export function resolve<T>(entry: Entry<T, Encoded<T>>): ZodMiniType<T, Encoded<T>> {
+  return isSchema(entry) ? built(entry).zod() : entry;
+}
+
+function built<T>(schema: Schema<T, Encoded<T>>): Built<T, Encoded<T>> {
+  return schema as Built<T, Encoded<T>>;
+}
+
+function isSchema<V, W>(entry: Entry<V, W>): entry is Schema<V, W> {
+  return typeof (entry as { decode?: unknown }).decode === "function";
+}