@aerostack/sdk-node 0.6.14 → 0.7.2

package/src/lib/primitives.ts

@@ -1,150 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-
-class InvariantError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "InvariantError";
-  }
-}
-
-export function invariant(
-  condition: unknown,
-  message: string,
-): asserts condition {
-  if (!condition) {
-    throw new InvariantError(message);
-  }
-}
-
-export type ExactPartial<T> = {
-  [P in keyof T]?: T[P] | undefined;
-};
-
-export type Remap<Inp, Mapping extends { [k in keyof Inp]?: string | null }> = {
-  [k in keyof Inp as Mapping[k] extends string /* if we have a string mapping for this key then use it */
-    ? Mapping[k]
-    : Mapping[k] extends null /* if the mapping is to `null` then drop the key */
-    ? never
-    : k /* otherwise keep the key as-is */]: Inp[k];
-};
-
-/**
- * Converts or omits an object's keys according to a mapping.
- *
- * @param inp An object whose keys will be remapped
- * @param mappings A mapping of original keys to new keys. If a key is not present in the mapping, it will be left as is. If a key is mapped to `null`, it will be removed in the resulting object.
- * @returns A new object with keys remapped or omitted according to the mappings
- */
-export function remap<
-  Inp extends Record<string, unknown>,
-  const Mapping extends { [k in keyof Inp]?: string | null },
->(inp: Inp, mappings: Mapping): Remap<Inp, Mapping> {
-  let out: any = {};
-
-  if (!Object.keys(mappings).length) {
-    out = inp;
-    return out;
-  }
-
-  for (const [k, v] of Object.entries(inp)) {
-    const j = mappings[k];
-    if (j === null) {
-      continue;
-    }
-    out[j ?? k] = v;
-  }
-
-  return out;
-}
-
-export function combineSignals(
-  ...signals: Array<AbortSignal | null | undefined>
-): AbortSignal | null {
-  const filtered: AbortSignal[] = [];
-  for (const signal of signals) {
-    if (signal) {
-      filtered.push(signal);
-    }
-  }
-
-  switch (filtered.length) {
-    case 0:
-    case 1:
-      return filtered[0] || null;
-    default:
-      if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
-        return AbortSignal.any(filtered);
-      }
-      return abortSignalAny(filtered);
-  }
-}
-
-export function abortSignalAny(signals: AbortSignal[]): AbortSignal {
-  const controller = new AbortController();
-  const result = controller.signal;
-  if (!signals.length) {
-    return controller.signal;
-  }
-
-  if (signals.length === 1) {
-    return signals[0] || controller.signal;
-  }
-
-  for (const signal of signals) {
-    if (signal.aborted) {
-      return signal;
-    }
-  }
-
-  function abort(this: AbortSignal) {
-    controller.abort(this.reason);
-    clean();
-  }
-
-  const signalRefs: WeakRef<AbortSignal>[] = [];
-  function clean() {
-    for (const signalRef of signalRefs) {
-      const signal = signalRef.deref();
-      if (signal) {
-        signal.removeEventListener("abort", abort);
-      }
-    }
-  }
-
-  for (const signal of signals) {
-    signalRefs.push(new WeakRef(signal));
-    signal.addEventListener("abort", abort);
-  }
-
-  return result;
-}
-
-export function compactMap<T>(
-  values: Record<string, T | undefined>,
-): Record<string, T> {
-  const out: Record<string, T> = {};
-
-  for (const [k, v] of Object.entries(values)) {
-    if (typeof v !== "undefined") {
-      out[k] = v;
-    }
-  }
-
-  return out;
-}
-
-export function allRequired<V extends Record<string, unknown>>(
-  v: V,
-):
-  | {
-      [K in keyof V]: NonNullable<V[K]>;
-    }
-  | undefined {
-  if (Object.values(v).every((x) => x == null)) {
-    return void 0;
-  }
-
-  return v as ReturnType<typeof allRequired<V>>;
-}

package/src/lib/retries.ts

@@ -1,218 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-
-import { isConnectionError, isTimeoutError } from "./http.js";
-
-export type BackoffStrategy = {
-  initialInterval: number;
-  maxInterval: number;
-  exponent: number;
-  maxElapsedTime: number;
-};
-
-const defaultBackoff: BackoffStrategy = {
-  initialInterval: 500,
-  maxInterval: 60000,
-  exponent: 1.5,
-  maxElapsedTime: 3600000,
-};
-
-export type RetryConfig =
-  | { strategy: "none" }
-  | {
-      strategy: "backoff";
-      backoff?: BackoffStrategy;
-      retryConnectionErrors?: boolean;
-    };
-
-/**
- * PermanentError is an error that is not recoverable. Throwing this error will
- * cause a retry loop to terminate.
- */
-export class PermanentError extends Error {
-  /** The underlying cause of the error. */
-  override readonly cause: unknown;
-
-  constructor(message: string, options?: { cause?: unknown }) {
-    let msg = message;
-    if (options?.cause) {
-      msg += `: ${options.cause}`;
-    }
-
-    super(msg, options);
-    this.name = "PermanentError";
-    // In older runtimes, the cause field would not have been assigned through
-    // the super() call.
-    if (typeof this.cause === "undefined") {
-      this.cause = options?.cause;
-    }
-
-    Object.setPrototypeOf(this, PermanentError.prototype);
-  }
-}
-
-/**
- * TemporaryError is an error is used to signal that an HTTP request can be
- * retried as part of a retry loop. If retry attempts are exhausted and this
- * error is thrown, the response will be returned to the caller.
- */
-export class TemporaryError extends Error {
-  response: Response;
-
-  constructor(message: string, response: Response) {
-    super(message);
-    this.response = response;
-    this.name = "TemporaryError";
-
-    Object.setPrototypeOf(this, TemporaryError.prototype);
-  }
-}
-
-export async function retry(
-  fetchFn: () => Promise<Response>,
-  options: {
-    config: RetryConfig;
-    statusCodes: string[];
-  },
-): Promise<Response> {
-  switch (options.config.strategy) {
-    case "backoff":
-      return retryBackoff(
-        wrapFetcher(fetchFn, {
-          statusCodes: options.statusCodes,
-          retryConnectionErrors: !!options.config.retryConnectionErrors,
-        }),
-        options.config.backoff ?? defaultBackoff,
-      );
-    default:
-      return await fetchFn();
-  }
-}
-
-function wrapFetcher(
-  fn: () => Promise<Response>,
-  options: {
-    statusCodes: string[];
-    retryConnectionErrors: boolean;
-  },
-): () => Promise<Response> {
-  return async () => {
-    try {
-      const res = await fn();
-      if (isRetryableResponse(res, options.statusCodes)) {
-        throw new TemporaryError(
-          "Response failed with retryable status code",
-          res,
-        );
-      }
-
-      return res;
-    } catch (err: unknown) {
-      if (err instanceof TemporaryError) {
-        throw err;
-      }
-
-      if (
-        options.retryConnectionErrors &&
-        (isTimeoutError(err) || isConnectionError(err))
-      ) {
-        throw err;
-      }
-
-      throw new PermanentError("Permanent error", { cause: err });
-    }
-  };
-}
-
-const codeRangeRE = new RegExp("^[0-9]xx$", "i");
-
-function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
-  const actual = `${res.status}`;
-
-  return statusCodes.some((code) => {
-    if (!codeRangeRE.test(code)) {
-      return code === actual;
-    }
-
-    const expectFamily = code.charAt(0);
-    if (!expectFamily) {
-      throw new Error("Invalid status code range");
-    }
-
-    const actualFamily = actual.charAt(0);
-    if (!actualFamily) {
-      throw new Error(`Invalid response status code: ${actual}`);
-    }
-
-    return actualFamily === expectFamily;
-  });
-}
-
-async function retryBackoff(
-  fn: () => Promise<Response>,
-  strategy: BackoffStrategy,
-): Promise<Response> {
-  const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy;
-
-  const start = Date.now();
-  let x = 0;
-
-  while (true) {
-    try {
-      const res = await fn();
-      return res;
-    } catch (err: unknown) {
-      if (err instanceof PermanentError) {
-        throw err.cause;
-      }
-      const elapsed = Date.now() - start;
-      if (elapsed > maxElapsedTime) {
-        if (err instanceof TemporaryError) {
-          return err.response;
-        }
-
-        throw err;
-      }
-
-      let retryInterval = 0;
-      if (err instanceof TemporaryError) {
-        retryInterval = retryIntervalFromResponse(err.response);
-      }
-
-      if (retryInterval <= 0) {
-        retryInterval =
-          initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
-      }
-
-      const d = Math.min(retryInterval, maxInterval);
-
-      await delay(d);
-      x++;
-    }
-  }
-}
-
-function retryIntervalFromResponse(res: Response): number {
-  const retryVal = res.headers.get("retry-after") || "";
-  if (!retryVal) {
-    return 0;
-  }
-
-  const parsedNumber = Number(retryVal);
-  if (Number.isInteger(parsedNumber)) {
-    return parsedNumber * 1000;
-  }
-
-  const parsedDate = Date.parse(retryVal);
-  if (Number.isInteger(parsedDate)) {
-    const deltaMS = parsedDate - Date.now();
-    return deltaMS > 0 ? Math.ceil(deltaMS) : 0;
-  }
-
-  return 0;
-}
-
-async function delay(delay: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, delay));
-}

package/src/lib/schemas.ts

@@ -1,91 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-
-import {
-  output,
-  ZodEffects,
-  ZodError,
-  ZodObject,
-  ZodRawShape,
-  ZodTypeAny,
-} from "zod/v3";
-import { SDKValidationError } from "../sdk/models/errors/sdkvalidationerror.js";
-import { ERR, OK, Result } from "../sdk/types/fp.js";
-
-/**
- * Utility function that executes some code which may throw a ZodError. It
- * intercepts this error and converts it to an SDKValidationError so as to not
- * leak Zod implementation details to user code.
- */
-export function parse<Inp, Out>(
-  rawValue: Inp,
-  fn: (value: Inp) => Out,
-  errorMessage: string,
-): Out {
-  try {
-    return fn(rawValue);
-  } catch (err) {
-    if (err instanceof ZodError) {
-      throw new SDKValidationError(errorMessage, err, rawValue);
-    }
-    throw err;
-  }
-}
-
-/**
- * Utility function that executes some code which may result in a ZodError. It
- * intercepts this error and converts it to an SDKValidationError so as to not
- * leak Zod implementation details to user code.
- */
-export function safeParse<Inp, Out>(
-  rawValue: Inp,
-  fn: (value: Inp) => Out,
-  errorMessage: string,
-): Result<Out, SDKValidationError> {
-  try {
-    return OK(fn(rawValue));
-  } catch (err) {
-    return ERR(new SDKValidationError(errorMessage, err, rawValue));
-  }
-}
-
-export function collectExtraKeys<
-  Shape extends ZodRawShape,
-  Catchall extends ZodTypeAny,
-  K extends string,
->(
-  obj: ZodObject<Shape, "strip", Catchall>,
-  extrasKey: K,
-  optional: boolean,
-): ZodEffects<
-  typeof obj,
-  & output<ZodObject<Shape, "strict">>
-  & {
-    [k in K]: Record<string, output<Catchall>>;
-  }
-> {
-  return obj.transform((val) => {
-    const extras: Record<string, output<Catchall>> = {};
-    const { shape } = obj;
-    for (const [key] of Object.entries(val)) {
-      if (key in shape) {
-        continue;
-      }
-
-      const v = val[key];
-      if (typeof v === "undefined") {
-        continue;
-      }
-
-      extras[key] = v;
-      delete val[key];
-    }
-
-    if (optional && Object.keys(extras).length === 0) {
-      return val;
-    }
-
-    return { ...val, [extrasKey]: extras };
-  });
-}