api-invoke 0.1.0

package/dist/chunk-TXAOTXB4.js

@@ -0,0 +1,543 @@
+// src/core/types.ts
+var HttpMethod = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  PATCH: "PATCH",
+  DELETE: "DELETE",
+  HEAD: "HEAD",
+  OPTIONS: "OPTIONS"
+};
+var ParamLocation = {
+  PATH: "path",
+  QUERY: "query",
+  HEADER: "header",
+  COOKIE: "cookie"
+};
+var AuthType = {
+  BEARER: "bearer",
+  BASIC: "basic",
+  API_KEY: "apiKey",
+  QUERY_PARAM: "queryParam",
+  OAUTH2: "oauth2",
+  COOKIE: "cookie"
+};
+var SpecFormat = {
+  OPENAPI_3: "openapi-3",
+  OPENAPI_2: "openapi-2",
+  RAW_URL: "raw-url",
+  MANUAL: "manual",
+  GRAPHQL: "graphql"
+};
+var HeaderName = {
+  ACCEPT: "Accept",
+  AUTHORIZATION: "Authorization",
+  CONTENT_TYPE: "Content-Type",
+  COOKIE: "Cookie"
+};
+var ContentType = {
+  JSON: "application/json",
+  FORM_URLENCODED: "application/x-www-form-urlencoded",
+  MULTIPART: "multipart/form-data",
+  XML: "application/xml",
+  OCTET_STREAM: "application/octet-stream",
+  TEXT: "text/plain",
+  SSE: "text/event-stream"
+};
+
+// src/core/errors.ts
+var ErrorKind = {
+  CORS: "cors",
+  NETWORK: "network",
+  AUTH: "auth",
+  HTTP: "http",
+  PARSE: "parse",
+  RATE_LIMIT: "rate-limit",
+  TIMEOUT: "timeout",
+  GRAPHQL: "graphql"
+};
+var API_INVOKE_ERROR_NAME = "ApiInvokeError";
+var ApiInvokeError = class extends Error {
+  /** Error classification for programmatic handling. */
+  kind;
+  /** HTTP status code, if the error originated from an HTTP response. */
+  status;
+  /** Human-readable suggestion for how to resolve this error. */
+  suggestion;
+  /** Whether retrying the request might succeed (e.g. true for rate limits, network errors). */
+  retryable;
+  /** Response body from the API (when available). May be parsed JSON, a string, or binary data depending on the response content type. */
+  responseBody;
+  constructor(opts) {
+    super(opts.message);
+    this.name = API_INVOKE_ERROR_NAME;
+    this.kind = opts.kind;
+    this.suggestion = opts.suggestion;
+    this.retryable = opts.retryable ?? false;
+    this.status = opts.status;
+    this.responseBody = opts.responseBody;
+  }
+};
+function corsError(url) {
+  return new ApiInvokeError({
+    kind: ErrorKind.CORS,
+    message: `Cannot access ${url} \u2014 blocked by CORS policy.`,
+    suggestion: "This API does not allow browser requests. Use a CORS proxy or server-side execution.",
+    retryable: false
+  });
+}
+function networkError(url) {
+  return new ApiInvokeError({
+    kind: ErrorKind.NETWORK,
+    message: `Network error while fetching ${url}.`,
+    suggestion: "Check your internet connection and verify the URL is correct.",
+    retryable: true
+  });
+}
+function authError(url, status, responseBody) {
+  return new ApiInvokeError({
+    kind: ErrorKind.AUTH,
+    message: status === 401 ? `Authentication failed for ${url} (401)` : `Authorization denied for ${url} (403)`,
+    suggestion: status === 401 ? "Check your credentials. The server rejected your authentication." : "Your credentials are valid but you lack permission for this resource.",
+    retryable: false,
+    status,
+    responseBody
+  });
+}
+function httpError(url, status, statusText, responseBody) {
+  const retryable = status === 429 || status >= 500;
+  const kind = status === 429 ? ErrorKind.RATE_LIMIT : ErrorKind.HTTP;
+  let suggestion;
+  if (status === 404) {
+    suggestion = "The endpoint was not found. Check the URL path.";
+  } else if (status === 429) {
+    suggestion = "Rate limited. Wait and retry.";
+  } else if (status >= 500) {
+    suggestion = "The API server is having issues. Try again later.";
+  } else {
+    suggestion = `The API returned an error (${status}). Verify the request.`;
+  }
+  return new ApiInvokeError({
+    kind,
+    message: `API returned ${status} ${statusText} for ${url}.`,
+    suggestion,
+    retryable,
+    status,
+    responseBody
+  });
+}
+function parseError(url, expectedType = "JSON") {
+  return new ApiInvokeError({
+    kind: ErrorKind.PARSE,
+    message: `Failed to parse response from ${url} as ${expectedType}.`,
+    suggestion: `The API response body could not be read as ${expectedType}. Verify the endpoint returns the expected content type.`,
+    retryable: false
+  });
+}
+function graphqlError(messages, status, responseBody) {
+  return new ApiInvokeError({
+    kind: ErrorKind.GRAPHQL,
+    message: `GraphQL errors: ${messages}`,
+    suggestion: "Check the query and variables for correctness.",
+    retryable: false,
+    status,
+    responseBody
+  });
+}
+function timeoutError(url) {
+  return new ApiInvokeError({
+    kind: ErrorKind.TIMEOUT,
+    message: `Request to ${url} timed out.`,
+    suggestion: "The server took too long to respond. Try again or increase the timeout.",
+    retryable: true
+  });
+}
+
+// src/adapters/graphql/introspection.ts
+var TypeKind = {
+  SCALAR: "SCALAR",
+  OBJECT: "OBJECT",
+  ENUM: "ENUM",
+  INPUT_OBJECT: "INPUT_OBJECT",
+  NON_NULL: "NON_NULL",
+  LIST: "LIST",
+  UNION: "UNION",
+  INTERFACE: "INTERFACE"
+};
+var INTROSPECTION_QUERY = `query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      kind name description
+      fields(includeDeprecated: false) {
+        name description
+        args { name description type { ...TypeRef } defaultValue }
+        type { ...TypeRef }
+      }
+      inputFields { name description type { ...TypeRef } defaultValue }
+      enumValues(includeDeprecated: false) { name description }
+    }
+  }
+}
+fragment TypeRef on __Type {
+  kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name } } } } } }
+}`;
+
+// src/adapters/graphql/query-builder.ts
+var DEFAULT_MAX_DEPTH = 2;
+function formatTypeRef(ref) {
+  if (ref.kind === TypeKind.NON_NULL) {
+    return ref.ofType ? `${formatTypeRef(ref.ofType)}!` : "unknown!";
+  }
+  if (ref.kind === TypeKind.LIST) {
+    return ref.ofType ? `[${formatTypeRef(ref.ofType)}]` : "[unknown]";
+  }
+  return ref.name ?? "unknown";
+}
+function unwrapType(ref) {
+  let current = ref;
+  while ((current.kind === TypeKind.NON_NULL || current.kind === TypeKind.LIST) && current.ofType) {
+    current = current.ofType;
+  }
+  return current;
+}
+function isNonNull(ref) {
+  return ref.kind === TypeKind.NON_NULL;
+}
+function buildQueryString(operationType, field, typeMap, maxDepth = DEFAULT_MAX_DEPTH) {
+  const varDefs = buildVariableDefinitions(field.args);
+  const fieldArgs = buildFieldArguments(field.args);
+  const selection = buildSelectionSet(field.type, typeMap, maxDepth, /* @__PURE__ */ new Set());
+  const varPart = varDefs ? `(${varDefs})` : "";
+  const argPart = fieldArgs ? `(${fieldArgs})` : "";
+  const selPart = selection ? ` ${selection}` : "";
+  return `${operationType} ${field.name}${varPart} { ${field.name}${argPart}${selPart} }`;
+}
+function buildVariableDefinitions(args) {
+  if (args.length === 0) return "";
+  return args.map((a) => `$${a.name}: ${formatTypeRef(a.type)}`).join(", ");
+}
+function buildFieldArguments(args) {
+  if (args.length === 0) return "";
+  return args.map((a) => `${a.name}: $${a.name}`).join(", ");
+}
+function buildSelectionSet(typeRef, typeMap, depth, visited) {
+  const base = unwrapType(typeRef);
+  if (!base.name) return "";
+  const type = typeMap.get(base.name);
+  if (!type || !type.fields) return "";
+  if (base.kind === TypeKind.UNION || base.kind === TypeKind.INTERFACE) {
+    return buildUnionSelection();
+  }
+  if (base.kind !== TypeKind.OBJECT) return "";
+  if (visited.has(base.name)) return "";
+  visited.add(base.name);
+  const fields = [];
+  for (const f of type.fields) {
+    const fieldBase = unwrapType(f.type);
+    if (fieldBase.kind === TypeKind.SCALAR || fieldBase.kind === TypeKind.ENUM) {
+      fields.push(f.name);
+    } else if (depth > 0 && (fieldBase.kind === TypeKind.OBJECT || fieldBase.kind === TypeKind.UNION || fieldBase.kind === TypeKind.INTERFACE)) {
+      const nested = buildSelectionSet(f.type, typeMap, depth - 1, new Set(visited));
+      if (nested) {
+        fields.push(`${f.name} ${nested}`);
+      }
+    }
+  }
+  visited.delete(base.name);
+  if (fields.length === 0) return "";
+  return `{ ${fields.join(" ")} }`;
+}
+function buildUnionSelection(type, typeMap, depth, visited) {
+  return "{ __typename }";
+}
+
+// src/adapters/graphql/parser.ts
+async function parseGraphQLSchema(input, options) {
+  const maxDepth = options?.maxDepth ?? 2;
+  let schema;
+  let endpoint;
+  if (typeof input === "string") {
+    if (!input.startsWith("http")) {
+      throw new ApiInvokeError({
+        kind: ErrorKind.PARSE,
+        message: "GraphQL input must be an endpoint URL (starting with http) or an introspection JSON object. SDL parsing is not yet supported.",
+        suggestion: 'Pass a URL like "https://api.example.com/graphql" or an introspection result object.',
+        retryable: false
+      });
+    }
+    endpoint = options?.endpoint ?? input;
+    schema = await fetchIntrospection(input, options?.fetch);
+  } else {
+    schema = extractSchema(input);
+    endpoint = options?.endpoint ?? "/graphql";
+  }
+  const path = extractPath(endpoint);
+  const typeMap = buildTypeMap(schema.types);
+  const operations = [];
+  if (schema.queryType?.name) {
+    const queryType = typeMap.get(schema.queryType.name);
+    if (queryType?.fields) {
+      for (const field of queryType.fields) {
+        operations.push(buildOperation(field, "query", path, typeMap, maxDepth));
+      }
+    }
+  }
+  if (schema.mutationType?.name) {
+    const mutationType = typeMap.get(schema.mutationType.name);
+    if (mutationType?.fields) {
+      for (const field of mutationType.fields) {
+        operations.push(buildOperation(field, "mutation", path, typeMap, maxDepth));
+      }
+    }
+  }
+  if (schema.subscriptionType?.name) {
+    const subType = typeMap.get(schema.subscriptionType.name);
+    if (subType?.fields) {
+      for (const field of subType.fields) {
+        operations.push(buildOperation(field, "subscription", path, typeMap, maxDepth));
+      }
+    }
+  }
+  const title = extractTitle(endpoint);
+  return {
+    title,
+    version: "1.0.0",
+    baseUrl: extractBaseUrl(endpoint),
+    operations,
+    authSchemes: [],
+    specFormat: SpecFormat.GRAPHQL
+  };
+}
+async function fetchIntrospection(url, fetchFn) {
+  const doFetch = fetchFn ?? globalThis.fetch;
+  let response;
+  try {
+    response = await doFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query: INTROSPECTION_QUERY })
+    });
+  } catch (err) {
+    throw new ApiInvokeError({
+      kind: ErrorKind.NETWORK,
+      message: `Failed to fetch GraphQL introspection from ${url}: ${err instanceof Error ? err.message : String(err)}`,
+      suggestion: "Check the endpoint URL and your network connection.",
+      retryable: true
+    });
+  }
+  if (!response.ok) {
+    throw new ApiInvokeError({
+      kind: ErrorKind.HTTP,
+      message: `GraphQL introspection failed with HTTP ${response.status} from ${url}.`,
+      suggestion: "Verify the endpoint supports introspection and is accessible.",
+      retryable: response.status >= 500,
+      status: response.status
+    });
+  }
+  let json;
+  const cloned = response.clone();
+  try {
+    json = await response.json();
+  } catch (err) {
+    let body;
+    try {
+      body = (await cloned.text()).slice(0, 200);
+    } catch {
+    }
+    throw new ApiInvokeError({
+      kind: ErrorKind.PARSE,
+      message: `GraphQL introspection response from ${url} is not valid JSON${err instanceof Error ? `: ${err.message}` : ""}.`,
+      suggestion: `The endpoint returned a non-JSON response${body ? ` (starts with: "${body}")` : ""}. Verify it is a GraphQL endpoint.`,
+      retryable: false
+    });
+  }
+  return extractSchema(json);
+}
+function extractSchema(obj) {
+  const record = obj;
+  if (record.__schema && typeof record.__schema === "object") {
+    return record.__schema;
+  }
+  if (record.data && typeof record.data === "object") {
+    const data = record.data;
+    if (data.__schema && typeof data.__schema === "object") {
+      return data.__schema;
+    }
+  }
+  throw new ApiInvokeError({
+    kind: ErrorKind.PARSE,
+    message: "Invalid GraphQL introspection result: expected { __schema: ... } or { data: { __schema: ... } }.",
+    suggestion: "Pass a valid introspection result object or a URL to a GraphQL endpoint.",
+    retryable: false
+  });
+}
+function buildTypeMap(types) {
+  const map = /* @__PURE__ */ new Map();
+  for (const type of types) {
+    map.set(type.name, type);
+  }
+  return map;
+}
+function extractPath(endpoint) {
+  try {
+    return new URL(endpoint).pathname;
+  } catch {
+    return "/graphql";
+  }
+}
+function extractBaseUrl(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    return url.origin;
+  } catch {
+    return "";
+  }
+}
+function extractTitle(endpoint, _schema) {
+  try {
+    const url = new URL(endpoint);
+    return `GraphQL API (${url.hostname})`;
+  } catch {
+    return "GraphQL API";
+  }
+}
+function buildOperation(field, operationType, path, typeMap, maxDepth) {
+  const id = operationType === "mutation" ? `mutation_${field.name}` : operationType === "subscription" ? `subscription_${field.name}` : field.name;
+  const tags = [operationType];
+  const queryString = operationType !== "subscription" ? buildQueryString(operationType, field, typeMap, maxDepth) : void 0;
+  const requestBody = buildRequestBody(field.args, typeMap);
+  const responseSchema = buildResponseSchema(field.type, typeMap);
+  const operation = {
+    id,
+    path,
+    method: HttpMethod.POST,
+    summary: field.description ?? `GraphQL ${operationType}: ${field.name}`,
+    parameters: [],
+    requestBody,
+    responseSchema,
+    tags
+  };
+  if (queryString) {
+    const argNames = new Set(field.args.map((a) => a.name));
+    operation.buildBody = (args) => {
+      const variables = {};
+      for (const [k, v] of Object.entries(args)) {
+        if (argNames.has(k)) variables[k] = v;
+      }
+      return { query: queryString, variables };
+    };
+  }
+  return operation;
+}
+function buildRequestBody(args, typeMap) {
+  if (args.length === 0) return void 0;
+  const properties = {};
+  const required = [];
+  for (const arg of args) {
+    properties[arg.name] = mapInputValueToProperty(arg, typeMap);
+    if (isNonNull(arg.type)) {
+      required.push(arg.name);
+    }
+  }
+  return {
+    required: required.length > 0,
+    contentType: ContentType.JSON,
+    schema: {
+      type: "object",
+      raw: { type: "object", properties },
+      properties,
+      required: required.length > 0 ? required : void 0
+    }
+  };
+}
+function mapInputValueToProperty(input, typeMap) {
+  const base = unwrapType(input.type);
+  const description = input.description ? `${input.description} (${formatTypeRef(input.type)})` : formatTypeRef(input.type);
+  const isList = isListType(input.type);
+  if (base.kind === TypeKind.SCALAR) {
+    const mapped = mapScalarType(base.name ?? "String");
+    const prop = {
+      type: isList ? "array" : mapped.type,
+      description
+    };
+    if (mapped.format) prop.format = mapped.format;
+    if (input.defaultValue != null) prop.default = input.defaultValue;
+    return prop;
+  }
+  if (base.kind === TypeKind.ENUM) {
+    const enumType = typeMap.get(base.name ?? "");
+    const enumValues = enumType?.enumValues?.map((e) => e.name);
+    return {
+      type: isList ? "array" : "string",
+      description,
+      enum: enumValues
+    };
+  }
+  if (base.kind === TypeKind.INPUT_OBJECT) {
+    return {
+      type: isList ? "array" : "object",
+      description,
+      nested: true
+    };
+  }
+  return { type: "string", description };
+}
+function isListType(ref) {
+  let current = ref;
+  while (current) {
+    if (current.kind === TypeKind.LIST) return true;
+    current = current.ofType;
+  }
+  return false;
+}
+function mapScalarType(name) {
+  switch (name) {
+    case "String":
+    case "ID":
+      return { type: "string" };
+    case "Int":
+      return { type: "integer" };
+    case "Float":
+      return { type: "number" };
+    case "Boolean":
+      return { type: "boolean" };
+    default:
+      return { type: "string", format: name.toLowerCase() };
+  }
+}
+function buildResponseSchema(typeRef, typeMap) {
+  const base = unwrapType(typeRef);
+  if (!base.name) return void 0;
+  if (base.kind === TypeKind.SCALAR) {
+    const mapped = mapScalarType(base.name);
+    return { type: mapped.type, format: mapped.format };
+  }
+  if (base.kind === TypeKind.ENUM) {
+    const enumType = typeMap.get(base.name);
+    return { type: "string", enum: enumType?.enumValues?.map((e) => e.name) };
+  }
+  if (base.kind === TypeKind.OBJECT) {
+    const objType = typeMap.get(base.name);
+    if (!objType?.fields) return { type: "object" };
+    const properties = {};
+    for (const f of objType.fields) {
+      const fieldBase = unwrapType(f.type);
+      if (fieldBase.kind === TypeKind.SCALAR) {
+        properties[f.name] = mapScalarType(fieldBase.name ?? "String");
+      } else if (fieldBase.kind === TypeKind.ENUM) {
+        properties[f.name] = { type: "string" };
+      } else {
+        properties[f.name] = { type: "object" };
+      }
+    }
+    return { type: "object", properties };
+  }
+  return { type: "object" };
+}
+
+export { API_INVOKE_ERROR_NAME, ApiInvokeError, AuthType, ContentType, ErrorKind, HeaderName, HttpMethod, ParamLocation, SpecFormat, authError, corsError, graphqlError, httpError, networkError, parseError, parseGraphQLSchema, timeoutError };
+//# sourceMappingURL=chunk-TXAOTXB4.js.map
+//# sourceMappingURL=chunk-TXAOTXB4.js.map