@fern-api/fdr-sdk 1.1.26-aaa1152cda → 1.1.28-306b323376

package/dist/js/api-definition-lite/index.mjs

@@ -0,0 +1,634 @@
+// src/orpc-client/shared.ts
+import * as z from "zod";
+var OrgIdSchema = z.string();
+var ApiIdSchema = z.string();
+var ApiDefinitionIdSchema = z.string().uuid();
+var HttpMethodSchema = z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+var UrlSchema = z.string();
+var EndpointPathLiteralSchema = z.string();
+function EndpointPathLiteral(value) {
+  return value;
+}
+var EndpointIdentifierSchema = z.object({
+  path: z.string(),
+  method: HttpMethodSchema,
+  identifierOverride: z.string().nullish()
+});
+var SdkRequestSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("typescript"), package: z.string(), version: z.string().nullish() }),
+  z.object({ type: z.literal("python"), package: z.string(), version: z.string().nullish() }),
+  z.object({ type: z.literal("go"), githubRepo: z.string(), version: z.string().nullish() }),
+  z.object({ type: z.literal("ruby"), gem: z.string(), version: z.string().nullish() }),
+  z.object({
+    type: z.literal("java"),
+    group: z.string(),
+    artifact: z.string(),
+    version: z.string().nullish()
+  }),
+  z.object({ type: z.literal("csharp"), package: z.string(), version: z.string().nullish() })
+]);
+var DocsConfigIdSchema = z.string();
+var GrpcIdSchema = z.string();
+var PageIdSchema = z.string();
+var RoleIdSchema = z.string();
+var TokenIdSchema = z.string();
+var VersionIdSchema = z.string();
+var Availability = {
+  Stable: "Stable",
+  GenerallyAvailable: "GenerallyAvailable",
+  InDevelopment: "InDevelopment",
+  PreRelease: "PreRelease",
+  Deprecated: "Deprecated",
+  Beta: "Beta"
+};
+var SnippetsByEndpointMethodSchema = z.record(
+  HttpMethodSchema,
+  z.array(z.unknown())
+);
+var SdkSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("typescript"), package: z.string(), version: z.string() }),
+  z.object({ type: z.literal("python"), package: z.string(), version: z.string() }),
+  z.object({ type: z.literal("go"), githubRepo: z.string(), version: z.string() }),
+  z.object({ type: z.literal("ruby"), gem: z.string(), version: z.string() }),
+  z.object({
+    type: z.literal("java"),
+    group: z.string(),
+    artifact: z.string(),
+    version: z.string()
+  }),
+  z.object({ type: z.literal("csharp"), package: z.string(), version: z.string() })
+]);
+
+// src/api-definition/endpoint-path-literal.ts
+function toColonEndpointPathLiteral(pathParts) {
+  return EndpointPathLiteral(
+    pathParts.map((part) => part.type === "literal" ? part.value : `:${part.value}`).join("")
+  );
+}
+function toCurlyBraceEndpointPathLiteral(pathParts) {
+  return EndpointPathLiteral(
+    pathParts.map((part) => part.type === "literal" ? part.value : `{${part.value}}`).join("")
+  );
+}
+
+// src/api-definition/status-message.ts
+var STATUS_CODE_MESSAGES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  103: "Early Hints",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  306: "Switch Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+var STATUS_CODE_MESSAGES_METHOD_OVERRIDES = {
+  200: {
+    GET: "Retrieved",
+    POST: "Successful",
+    // more accurate than "Created" for POST
+    PUT: "Updated",
+    PATCH: "Updated",
+    DELETE: "Deleted"
+  }
+};
+function getMessageForStatus(statusCode, method) {
+  if (method != null) {
+    const methodOverrides = STATUS_CODE_MESSAGES_METHOD_OVERRIDES[statusCode];
+    if (methodOverrides != null) {
+      const message2 = methodOverrides[method];
+      if (message2 != null) {
+        return message2;
+      }
+    }
+  }
+  const message = STATUS_CODE_MESSAGES[statusCode];
+  if (message != null) {
+    return message;
+  }
+  if (statusCode >= 100 && statusCode < 200) {
+    return "Informational";
+  } else if (statusCode >= 200 && statusCode < 300) {
+    return "Success";
+  } else if (statusCode >= 300 && statusCode < 400) {
+    return "Redirection";
+  } else if (statusCode >= 400 && statusCode < 500) {
+    return "Client Error";
+  } else if (statusCode >= 500 && statusCode < 600) {
+    return "Server Error";
+  } else {
+    return "Unknown Status";
+  }
+}
+
+// ../commons/core-utils/dist/assertNever.js
+function assertNever(x) {
+  throw new Error("Unexpected value: " + JSON.stringify(x));
+}
+
+// ../commons/core-utils/dist/objects/isPlainObject.js
+function isPlainObject(value) {
+  if (!isObjectLike(value) || String(value) !== "[object Object]") {
+    return false;
+  }
+  if (Object.getPrototypeOf(value) == null) {
+    return true;
+  }
+  let proto = value;
+  while (Object.getPrototypeOf(proto) != null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+function isObjectLike(value) {
+  return typeof value === "object" && value != null;
+}
+
+// ../commons/core-utils/dist/sanitizeUrl.js
+function sanitizeUrl(url) {
+  if (!url) {
+    return void 0;
+  }
+  if (url.startsWith("//")) {
+    try {
+      const parsedUrl = new URL(`https:${url}`);
+      return parsedUrl.toString();
+    } catch {
+      return void 0;
+    }
+  }
+  if (!url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("wss://") && !url.startsWith("ws://") && !url.startsWith("mailto:") && !url.startsWith("tel:")) {
+    try {
+      const parsedUrl = new URL(`https://${url}`);
+      return parsedUrl.toString();
+    } catch {
+      return void 0;
+    }
+  }
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.toString();
+  } catch {
+    return void 0;
+  }
+}
+
+// ../commons/core-utils/dist/unknownToString.js
+function unknownToString(value, { renderNull = false } = {}) {
+  if (value == null || typeof value === "function") {
+    return renderNull ? "null" : "";
+  } else if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+
+// ../commons/core-utils/dist/visitDiscriminatedUnion.js
+function visitDiscriminatedUnion(item, discriminant = "type") {
+  return {
+    _visit: (visitor) => {
+      const visit = visitor[item[discriminant]];
+      if (visit != null) {
+        return visit(item);
+      } else {
+        if (visitor._other == null) {
+          assertNever(item);
+        }
+        return visitor._other(item);
+      }
+    }
+  };
+}
+var visitDiscriminatedUnion_default = visitDiscriminatedUnion;
+
+// src/api-definition/unwrap.ts
+import { compact, sortBy } from "es-toolkit/array";
+
+// src/api-definition/availability.ts
+var AvailabilityOrder = [
+  Availability.Stable,
+  Availability.GenerallyAvailable,
+  Availability.Beta,
+  Availability.PreRelease,
+  Availability.InDevelopment,
+  Availability.Deprecated
+];
+function coalesceAvailability(availabilities) {
+  for (const availability of [...AvailabilityOrder].reverse()) {
+    if (availabilities.includes(availability)) {
+      return availability;
+    }
+  }
+  return void 0;
+}
+
+// src/api-definition/const.ts
+var LOOP_TOLERANCE = 100;
+var LARGE_LOOP_TOLERANCE = 100 ** 2;
+
+// src/api-definition/unwrap.ts
+var UnwrapReferenceCache = /* @__PURE__ */ new WeakMap();
+function unwrapReference(typeRef, types) {
+  if (typeRef == null) {
+    return void 0;
+  }
+  const cached = UnwrapReferenceCache.get(typeRef);
+  if (cached != null) {
+    return cached;
+  }
+  let isOptional = false;
+  let isNullable = false;
+  const defaults = [];
+  const descriptions = [];
+  const availabilities = [];
+  const visitedTypeIds = /* @__PURE__ */ new Set();
+  let internalTypeRef = typeRef;
+  let loop = 0;
+  let circularReference = false;
+  while (internalTypeRef != null) {
+    if (loop > LOOP_TOLERANCE) {
+      internalTypeRef = void 0;
+      break;
+    }
+    if (internalTypeRef.type === "nullable") {
+      isNullable = true;
+      internalTypeRef = internalTypeRef.shape;
+    } else if (internalTypeRef.type === "optional") {
+      isOptional = true;
+      if (internalTypeRef.default != null) {
+        defaults.push({
+          type: "unknown",
+          value: internalTypeRef.default
+        });
+      }
+      internalTypeRef = internalTypeRef.shape;
+    } else if (internalTypeRef.type === "alias") {
+      internalTypeRef = internalTypeRef.value;
+    } else if (internalTypeRef.type === "id") {
+      if (visitedTypeIds.has(internalTypeRef.id)) {
+        internalTypeRef = void 0;
+        circularReference = true;
+        break;
+      }
+      if (internalTypeRef.default != null) {
+        defaults.push({
+          type: "typeReferenceId",
+          value: internalTypeRef.default
+        });
+      }
+      const typeDef = types[internalTypeRef.id];
+      visitedTypeIds.add(internalTypeRef.id);
+      internalTypeRef = typeDef?.shape;
+      if (typeDef != null) {
+        if (typeDef.availability) {
+          availabilities.push(typeDef.availability);
+        }
+        if (typeDef.description != null) {
+          descriptions.push(typeDef.description);
+        }
+      }
+    } else {
+      break;
+    }
+    loop++;
+  }
+  if (internalTypeRef == null) {
+    if (circularReference) {
+      console.error(
+        `Circular reference detected. Falling back to unknown type. types=[${[...visitedTypeIds].join(", ")}]`
+      );
+    } else {
+      console.error(
+        `Type reference is invalid. Falling back to unknown type. types=[${[...visitedTypeIds].join(", ")}]`
+      );
+    }
+  }
+  const toRet = {
+    shape: internalTypeRef ?? { type: "unknown", displayName: void 0 },
+    availability: coalesceAvailability(availabilities),
+    visitedTypeIds,
+    isOptional,
+    isNullable,
+    default: selectDefaultValue(internalTypeRef, defaults),
+    descriptions
+  };
+  UnwrapReferenceCache.set(typeRef, toRet);
+  return toRet;
+}
+function selectDefaultValue(shape, defaults) {
+  const defaultValue = defaults.find((d) => {
+    if (shape == null) {
+      return true;
+    } else if (d.type === "typeReferenceId") {
+      return visitDiscriminatedUnion_default(d.value)._visit({
+        enum: () => shape?.type === "enum"
+      });
+    } else {
+      return true;
+    }
+  });
+  if (defaultValue?.type === "unknown") {
+    return defaultValue.value;
+  } else if (defaultValue?.type === "typeReferenceId") {
+    return defaultValue.value.value;
+  } else if (shape?.type === "primitive") {
+    return primitiveToDefault(shape.value);
+  } else if (shape?.type === "enum") {
+    return shape.default;
+  } else {
+    return void 0;
+  }
+}
+var UnwrapObjectTypeCache = /* @__PURE__ */ new WeakMap();
+function unwrapObjectType(object2, types, parentVisitedTypeIds) {
+  const cached = UnwrapObjectTypeCache.get(object2);
+  if (cached != null) {
+    return cached;
+  }
+  const directProperties = object2.properties;
+  const extraProperties = object2.extraProperties;
+  const descriptions = [];
+  const visitedTypeIds = /* @__PURE__ */ new Set();
+  const extendedProperties = object2.extends.flatMap((typeId) => {
+    if (parentVisitedTypeIds?.has(typeId)) {
+      console.error(`Circular reference detected. Cannot extend type=${typeId}`);
+      return [];
+    }
+    const typeDef = types[typeId];
+    visitedTypeIds.add(typeId);
+    if (typeDef?.description) {
+      descriptions.push(typeDef.description);
+    }
+    const unwrapped = unwrapReference(typeDef?.shape, types);
+    unwrapped?.descriptions.forEach((description) => descriptions.push(description));
+    unwrapped?.visitedTypeIds.forEach((typeId2) => visitedTypeIds.add(typeId2));
+    if (unwrapped?.shape.type !== "object") {
+      console.warn("Object extends non-object", typeId);
+      return [];
+    }
+    const extended = unwrapObjectType(unwrapped.shape, types, visitedTypeIds);
+    extended.visitedTypeIds.forEach((typeId2) => visitedTypeIds.add(typeId2));
+    const extendedPropsWithAvailability = extended.properties.map((property) => {
+      return {
+        ...property,
+        availability: coalesceAvailability(
+          compact([typeDef?.availability, unwrapped.availability, property.availability])
+        )
+      };
+    });
+    descriptions.push(...extended.descriptions);
+    if (!unwrapped.isOptional) {
+      return extendedPropsWithAvailability;
+    }
+    return extendedPropsWithAvailability.map((property) => {
+      const defaultProperty = isPlainObject(unwrapped.default) ? unwrapped.default[property.key] : void 0;
+      const valueShape = property.valueShape.type === "alias" && property.valueShape.value.type === "optional" ? {
+        ...property.valueShape.value,
+        default: defaultProperty ?? property.valueShape.value.default
+      } : {
+        type: "optional",
+        shape: property.valueShape,
+        default: defaultProperty
+      };
+      return {
+        ...property,
+        valueShape: { type: "alias", value: valueShape }
+      };
+    });
+  });
+  if (extendedProperties.length === 0) {
+    const properties2 = sortBy(
+      [...directProperties],
+      [
+        (property) => unwrapReference(property.valueShape, types)?.isOptional,
+        (property) => AvailabilityOrder.indexOf(property.availability ?? Availability.Stable)
+      ]
+    );
+    const toRet2 = {
+      properties: properties2,
+      descriptions,
+      extraProperties,
+      visitedTypeIds
+    };
+    UnwrapObjectTypeCache.set(object2, toRet2);
+    return toRet2;
+  }
+  const propertyKeys = new Set(object2.properties.map((property) => property.key));
+  const seenExtendedKeys = /* @__PURE__ */ new Set();
+  const filteredExtendedProperties = extendedProperties.filter((extendedProperty) => {
+    if (propertyKeys.has(extendedProperty.key) || seenExtendedKeys.has(extendedProperty.key)) {
+      return false;
+    }
+    seenExtendedKeys.add(extendedProperty.key);
+    return true;
+  });
+  const properties = sortBy(
+    [...directProperties, ...filteredExtendedProperties],
+    [
+      (property) => unwrapReference(property.valueShape, types)?.isOptional,
+      (property) => AvailabilityOrder.indexOf(property.availability ?? Availability.Stable),
+      (property) => property.key
+    ]
+  );
+  const toRet = { properties, descriptions, extraProperties, visitedTypeIds };
+  UnwrapObjectTypeCache.set(object2, toRet);
+  return toRet;
+}
+function unwrapDiscriminatedUnionVariant(union, variant, types) {
+  const { properties, descriptions, visitedTypeIds } = unwrapObjectType(variant, types);
+  return {
+    properties: [
+      {
+        key: union.discriminant,
+        valueShape: {
+          type: "alias",
+          value: {
+            type: "literal",
+            value: {
+              type: "stringLiteral",
+              value: variant.discriminantValue
+            }
+          }
+        },
+        propertyAccess: void 0,
+        // the description and availability of the discriminant should not be included here
+        // because they are already included in the union variant itself
+        description: void 0,
+        availability: void 0
+      },
+      ...properties
+    ],
+    extraProperties: void 0,
+    descriptions,
+    visitedTypeIds
+  };
+}
+function primitiveToDefault(shape) {
+  return visitDiscriminatedUnion_default(shape, "type")._visit({
+    string: (value) => value.default,
+    integer: (value) => value.default,
+    double: (value) => value.default,
+    uint: () => void 0,
+    uint64: () => void 0,
+    boolean: (value) => value.default,
+    long: (value) => value.default,
+    datetime: (datetime) => datetime.default,
+    uuid: (uuid) => uuid.default,
+    base64: (base64) => base64.default,
+    date: (value) => value.default,
+    bigInteger: (value) => value.default,
+    scalar: (value) => value.default
+  });
+}
+
+// src/api-definition/url.ts
+import qs from "qs";
+function preprocessQueryParameters(queryParameters, parameterMetadata) {
+  if (queryParameters == null) {
+    return void 0;
+  }
+  if (parameterMetadata == null || parameterMetadata.length === 0) {
+    return queryParameters;
+  }
+  const explodeMap = /* @__PURE__ */ new Map();
+  for (const param of parameterMetadata) {
+    explodeMap.set(param.key, param.explode ?? void 0);
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(queryParameters)) {
+    const explode = explodeMap.get(key);
+    if (explode === false && Array.isArray(value)) {
+      result[key] = value.map((v) => unknownToString(v)).join(",");
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function buildQueryParams(queryParameters) {
+  if (queryParameters == null) {
+    return "";
+  }
+  const filteredParams = Object.entries(queryParameters).reduce((acc, [key, value]) => {
+    if (value != null) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+  if (Object.keys(filteredParams).length === 0) {
+    return "";
+  }
+  const queryString = qs.stringify(filteredParams, {
+    encode: false,
+    arrayFormat: "repeat",
+    skipNulls: true,
+    serializeDate: (date) => date.toISOString()
+  });
+  return queryString ? "?" + queryString : "";
+}
+function buildPath(path = [], pathParameters) {
+  return path.map((part) => {
+    if (part.type === "pathParameter") {
+      const key = part.value;
+      const stateValue = unknownToString(pathParameters?.[key]);
+      return stateValue.length > 0 ? encodeURIComponent(stateValue) : ":" + key;
+    }
+    return part.value;
+  }).join("");
+}
+function buildRequestUrl({
+  baseUrl = "",
+  path,
+  pathParameters,
+  queryParameters
+}) {
+  const sanitizedBaseUrl = sanitizeUrl(baseUrl) || "";
+  if (sanitizedBaseUrl.endsWith("/")) {
+    return sanitizedBaseUrl.slice(0, -1) + buildPath(path, pathParameters) + buildQueryParams(queryParameters);
+  }
+  return sanitizedBaseUrl + buildPath(path, pathParameters) + buildQueryParams(queryParameters);
+}
+function buildEndpointUrl({
+  endpoint,
+  pathParameters,
+  queryParameters,
+  baseUrl
+}) {
+  const environmentBaseUrl = baseUrl ?? (endpoint?.environments?.find((env) => env.id === endpoint.defaultEnvironment) ?? endpoint?.environments?.[0])?.baseUrl;
+  const sanitizedBaseUrl = sanitizeUrl(environmentBaseUrl);
+  const processedQueryParameters = preprocessQueryParameters(queryParameters, endpoint?.queryParameters ?? void 0);
+  return buildRequestUrl({
+    baseUrl: sanitizedBaseUrl || "",
+    path: endpoint?.path,
+    pathParameters,
+    queryParameters: processedQueryParameters
+  });
+}
+export {
+  STATUS_CODE_MESSAGES,
+  buildEndpointUrl,
+  buildRequestUrl,
+  getMessageForStatus,
+  preprocessQueryParameters,
+  toColonEndpointPathLiteral,
+  toCurlyBraceEndpointPathLiteral,
+  unwrapDiscriminatedUnionVariant,
+  unwrapObjectType,
+  unwrapReference
+};
+//# sourceMappingURL=index.mjs.map