@xylex-group/athena 2.4.1 → 2.6.0

package/dist/cli/index.js

@@ -1504,7 +1504,7 @@ var getSessionCookie = (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.4.1"
+  version: "2.6.0"
 };
 
 // src/sdk-version.ts
@@ -3479,6 +3479,684 @@ function createDbModule(input) {
   return db;
 }
 
+// src/storage/module.ts
+var storageSdkManifest = {
+  methods: [
+    {
+      name: "listStorageCatalogs",
+      method: "GET",
+      path: "/storage/catalogs",
+      responseEnvelope: "raw",
+      responseType: "{ data: S3CatalogItem[] }"
+    },
+    {
+      name: "createStorageCatalog",
+      method: "POST",
+      path: "/storage/catalogs",
+      requestType: "CreateStorageCatalogRequest",
+      responseEnvelope: "raw",
+      responseType: "S3CatalogItem"
+    },
+    {
+      name: "updateStorageCatalog",
+      method: "PATCH",
+      path: "/storage/catalogs/{id}",
+      pathParams: ["id"],
+      requestType: "UpdateStorageCatalogRequest",
+      responseEnvelope: "raw",
+      responseType: "S3CatalogItem"
+    },
+    {
+      name: "deleteStorageCatalog",
+      method: "DELETE",
+      path: "/storage/catalogs/{id}",
+      pathParams: ["id"],
+      responseEnvelope: "raw",
+      responseType: "{ id: string; deleted: boolean }"
+    },
+    {
+      name: "listStorageCredentials",
+      method: "GET",
+      path: "/storage/credentials",
+      responseEnvelope: "raw",
+      responseType: "{ data: S3CredentialListItem[] }"
+    },
+    {
+      name: "createStorageUploadUrl",
+      method: "POST",
+      path: "/storage/files/upload-url",
+      requestType: "CreateStorageUploadUrlRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageUploadUrlResponse"
+    },
+    {
+      name: "createStorageUploadUrls",
+      method: "POST",
+      path: "/storage/files/upload-urls",
+      requestType: "CreateStorageUploadUrlsRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageBatchUploadUrlResponse"
+    },
+    {
+      name: "listStorageFiles",
+      method: "POST",
+      path: "/storage/files/list",
+      requestType: "ListStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageListFilesResponse"
+    },
+    {
+      name: "getStorageFile",
+      method: "GET",
+      path: "/storage/files/{file_id}",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "getStorageFileUrl",
+      method: "GET",
+      path: "/storage/files/{file_id}/url",
+      pathParams: ["file_id"],
+      queryParams: ["purpose"],
+      responseEnvelope: "athena",
+      responseType: "PresignedFileUrlResponse"
+    },
+    {
+      name: "getStorageFileProxy",
+      method: "GET",
+      path: "/storage/files/{file_id}/proxy",
+      pathParams: ["file_id"],
+      queryParams: ["purpose"],
+      responseEnvelope: "raw",
+      responseType: "Response",
+      binary: true
+    },
+    {
+      name: "updateStorageFile",
+      method: "PATCH",
+      path: "/storage/files/{file_id}",
+      pathParams: ["file_id"],
+      requestType: "UpdateStorageFileRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "deleteStorageFile",
+      method: "DELETE",
+      path: "/storage/files/{file_id}",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "setStorageFileVisibility",
+      method: "PATCH",
+      path: "/storage/files/{file_id}/visibility",
+      pathParams: ["file_id"],
+      requestType: "SetStorageFileVisibilityRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "deleteStorageFolder",
+      method: "POST",
+      path: "/storage/folders/delete",
+      requestType: "DeleteStorageFolderRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFolderMutationResponse"
+    },
+    {
+      name: "moveStorageFolder",
+      method: "POST",
+      path: "/storage/folders/move",
+      requestType: "MoveStorageFolderRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFolderMutationResponse"
+    }
+  ]
+};
+var AthenaStorageError = class extends Error {
+  code;
+  athenaCode;
+  kind;
+  category;
+  retryable;
+  status;
+  endpoint;
+  method;
+  requestId;
+  hint;
+  causeDetail;
+  raw;
+  normalized;
+  __athenaNormalizedError;
+  constructor(input) {
+    super(input.message, { cause: input.cause });
+    this.name = "AthenaStorageError";
+    this.code = input.code;
+    this.status = input.status;
+    this.endpoint = input.endpoint;
+    this.method = input.method;
+    this.requestId = input.requestId;
+    this.hint = input.hint;
+    this.causeDetail = causeToString(input.cause);
+    this.raw = input.raw ?? null;
+    this.normalized = normalizeStorageErrorInput(input);
+    this.__athenaNormalizedError = this.normalized;
+    this.athenaCode = this.normalized.code;
+    this.kind = this.normalized.kind;
+    this.category = this.normalized.category;
+    this.retryable = this.normalized.retryable;
+    Object.defineProperty(this, "__athenaNormalizedError", {
+      value: this.normalized,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+  }
+  toDetails() {
+    return {
+      code: this.code,
+      athenaCode: this.athenaCode,
+      kind: this.kind,
+      category: this.category,
+      retryable: this.retryable,
+      message: this.message,
+      status: this.status,
+      endpoint: this.endpoint,
+      method: this.method,
+      requestId: this.requestId,
+      hint: this.hint,
+      cause: this.causeDetail,
+      raw: this.raw
+    };
+  }
+};
+function isRecord5(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function causeToString(cause) {
+  if (cause === void 0 || cause === null) return void 0;
+  if (typeof cause === "string") return cause;
+  if (cause instanceof Error && cause.message.trim()) return cause.message.trim();
+  try {
+    return JSON.stringify(cause);
+  } catch {
+    return String(cause);
+  }
+}
+function storageGatewayCode(code) {
+  if (code === "INVALID_URL") return "INVALID_URL";
+  if (code === "NETWORK_ERROR") return "NETWORK_ERROR";
+  if (code === "INVALID_JSON" || code === "INVALID_ATHENA_ENVELOPE") return "INVALID_JSON";
+  if (code === "HTTP_ERROR") return "HTTP_ERROR";
+  return "UNKNOWN_ERROR";
+}
+function headerValue(headers, names) {
+  for (const name of names) {
+    const value = headers.get(name);
+    if (value?.trim()) return value.trim();
+  }
+  return void 0;
+}
+function storageOperationFromEndpoint(endpoint, method) {
+  const endpointPath = String(endpoint).split("?")[0];
+  for (const candidate of storageSdkManifest.methods) {
+    if (candidate.method !== method) continue;
+    const pattern = `^${candidate.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\{[^/]+\\\}/g, "[^/]+")}$`;
+    if (new RegExp(pattern).test(endpointPath)) {
+      return candidate.name;
+    }
+  }
+  return `storage:${method.toLowerCase()}`;
+}
+function normalizeStorageErrorInput(input) {
+  return normalizeAthenaError(
+    {
+      data: null,
+      error: {
+        message: input.message,
+        gatewayCode: storageGatewayCode(input.code),
+        status: input.status,
+        raw: input.raw ?? input.cause ?? null
+      },
+      errorDetails: {
+        code: storageGatewayCode(input.code),
+        message: input.message,
+        status: input.status,
+        endpoint: input.endpoint,
+        method: input.method,
+        requestId: input.requestId,
+        hint: input.hint,
+        cause: causeToString(input.cause)
+      },
+      raw: input.raw ?? input.cause ?? null,
+      status: input.status
+    },
+    { operation: storageOperationFromEndpoint(input.endpoint, input.method) }
+  );
+}
+function createAthenaStorageError(input) {
+  return new AthenaStorageError(input);
+}
+async function notifyStorageError(error, options, runtimeOptions) {
+  const handlers = [runtimeOptions?.onError, options?.onError].filter(
+    (handler) => typeof handler === "function"
+  );
+  for (const handler of handlers) {
+    try {
+      await handler(error);
+    } catch {
+    }
+  }
+}
+async function rejectStorageError(input, options, runtimeOptions) {
+  const error = createAthenaStorageError(input);
+  await notifyStorageError(error, options, runtimeOptions);
+  throw error;
+}
+function parseResponseBody3(rawText, contentType) {
+  if (!rawText) {
+    return { parsed: null, parseFailed: false };
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return { parsed: rawText, parseFailed: false };
+  }
+  try {
+    return { parsed: JSON.parse(rawText), parseFailed: false };
+  } catch {
+    return { parsed: rawText, parseFailed: true };
+  }
+}
+function appendQuery(path, query) {
+  if (!query) return path;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, String(value));
+  }
+  const queryText = params.toString();
+  return queryText ? `${path}?${queryText}` : path;
+}
+function storagePath(path) {
+  return path;
+}
+function withPathParam(path, name, value) {
+  return path.replace(`{${name}}`, encodeURIComponent(value));
+}
+function resolveErrorMessage3(payload, fallback) {
+  if (isRecord5(payload)) {
+    const message = payload.message ?? payload.error ?? payload.details;
+    if (typeof message === "string" && message.trim()) {
+      return message.trim();
+    }
+  }
+  if (typeof payload === "string" && payload.trim()) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function resolveErrorHint2(payload) {
+  if (!isRecord5(payload)) return void 0;
+  const hint = payload.hint ?? payload.suggestion;
+  return typeof hint === "string" && hint.trim() ? hint.trim() : void 0;
+}
+function resolveErrorCause(payload) {
+  if (!isRecord5(payload)) return void 0;
+  const cause = payload.cause ?? payload.reason;
+  return typeof cause === "string" && cause.trim() ? cause.trim() : void 0;
+}
+function storageCodeFromUnknown(error) {
+  if (isAthenaGatewayError(error)) {
+    if (error.code === "INVALID_URL") return "INVALID_URL";
+    if (error.code === "NETWORK_ERROR") return "NETWORK_ERROR";
+    if (error.code === "INVALID_JSON") return "INVALID_JSON";
+    if (error.code === "HTTP_ERROR") return "HTTP_ERROR";
+  }
+  return "UNKNOWN_ERROR";
+}
+async function callStorageEndpoint(gateway, endpoint, method, envelope, payload, options, runtimeOptions) {
+  let url;
+  let headers;
+  try {
+    const baseUrl = options?.baseUrl ? normalizeAthenaGatewayBaseUrl(options.baseUrl) : gateway.baseUrl;
+    url = buildAthenaGatewayUrl(baseUrl, endpoint);
+    headers = gateway.buildHeaders(options);
+  } catch (error) {
+    return rejectStorageError(
+      {
+        code: storageCodeFromUnknown(error),
+        message: error instanceof Error ? error.message : `Athena storage ${method} ${endpoint} failed before sending the request`,
+        status: isAthenaGatewayError(error) ? error.status : 0,
+        endpoint,
+        method,
+        raw: error,
+        requestId: isAthenaGatewayError(error) ? error.requestId : void 0,
+        hint: isAthenaGatewayError(error) ? error.hint : void 0,
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  const requestInit = {
+    method,
+    headers,
+    signal: options?.signal
+  };
+  if (payload !== void 0 && method !== "GET") {
+    requestInit.body = JSON.stringify(payload);
+  }
+  let response;
+  try {
+    response = await fetch(url, requestInit);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return rejectStorageError(
+      {
+        code: "NETWORK_ERROR",
+        message: `Network error while calling Athena storage ${method} ${endpoint}: ${message}`,
+        status: 0,
+        endpoint,
+        method,
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  let rawText;
+  try {
+    rawText = await response.text();
+  } catch (error) {
+    return rejectStorageError(
+      {
+        code: "NETWORK_ERROR",
+        message: `Athena storage ${method} ${endpoint} response body could not be read`,
+        status: response.status,
+        endpoint,
+        method,
+        requestId: headerValue(response.headers, ["x-athena-request-id", "x-request-id", "request-id"]),
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  const parsedBody = parseResponseBody3(rawText ?? "", response.headers.get("content-type"));
+  const requestId = headerValue(response.headers, ["x-athena-request-id", "x-request-id", "request-id"]);
+  if (parsedBody.parseFailed) {
+    return rejectStorageError(
+      {
+        code: "INVALID_JSON",
+        message: `Athena storage ${method} ${endpoint} returned malformed JSON`,
+        status: response.status,
+        endpoint,
+        method,
+        requestId,
+        raw: parsedBody.parsed
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  if (!response.ok) {
+    return rejectStorageError(
+      {
+        code: "HTTP_ERROR",
+        message: resolveErrorMessage3(
+          parsedBody.parsed,
+          `Athena storage ${method} ${endpoint} failed with status ${response.status}`
+        ),
+        status: response.status,
+        endpoint,
+        method,
+        requestId,
+        hint: resolveErrorHint2(parsedBody.parsed),
+        cause: resolveErrorCause(parsedBody.parsed),
+        raw: parsedBody.parsed
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  if (envelope === "athena") {
+    if (!isRecord5(parsedBody.parsed) || !("data" in parsedBody.parsed)) {
+      return rejectStorageError(
+        {
+          code: "INVALID_ATHENA_ENVELOPE",
+          message: `Athena storage ${method} ${endpoint} returned an invalid Athena envelope`,
+          status: response.status,
+          endpoint,
+          method,
+          requestId,
+          raw: parsedBody.parsed
+        },
+        options,
+        runtimeOptions
+      );
+    }
+    return parsedBody.parsed.data;
+  }
+  return parsedBody.parsed;
+}
+async function callStorageBinaryEndpoint(gateway, endpoint, method, options, runtimeOptions) {
+  let url;
+  let headers;
+  try {
+    const baseUrl = options?.baseUrl ? normalizeAthenaGatewayBaseUrl(options.baseUrl) : gateway.baseUrl;
+    url = buildAthenaGatewayUrl(baseUrl, endpoint);
+    headers = gateway.buildHeaders(options);
+  } catch (error) {
+    return rejectStorageError(
+      {
+        code: storageCodeFromUnknown(error),
+        message: error instanceof Error ? error.message : `Athena storage ${method} ${endpoint} failed before sending the request`,
+        status: isAthenaGatewayError(error) ? error.status : 0,
+        endpoint,
+        method,
+        raw: error,
+        requestId: isAthenaGatewayError(error) ? error.requestId : void 0,
+        hint: isAthenaGatewayError(error) ? error.hint : void 0,
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      signal: options?.signal
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return rejectStorageError(
+      {
+        code: "NETWORK_ERROR",
+        message: `Network error while calling Athena storage ${method} ${endpoint}: ${message}`,
+        status: 0,
+        endpoint,
+        method,
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  if (response.ok) {
+    return response;
+  }
+  const requestId = headerValue(response.headers, ["x-athena-request-id", "x-request-id", "request-id"]);
+  let rawErrorBody = null;
+  try {
+    const rawText = await response.text();
+    const parsedBody = parseResponseBody3(rawText ?? "", response.headers.get("content-type"));
+    rawErrorBody = parsedBody.parsed;
+  } catch (error) {
+    return rejectStorageError(
+      {
+        code: "NETWORK_ERROR",
+        message: `Athena storage ${method} ${endpoint} error response body could not be read`,
+        status: response.status,
+        endpoint,
+        method,
+        requestId,
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  return rejectStorageError(
+    {
+      code: "HTTP_ERROR",
+      message: resolveErrorMessage3(
+        rawErrorBody,
+        `Athena storage ${method} ${endpoint} failed with status ${response.status}`
+      ),
+      status: response.status,
+      endpoint,
+      method,
+      requestId,
+      hint: resolveErrorHint2(rawErrorBody),
+      cause: resolveErrorCause(rawErrorBody),
+      raw: rawErrorBody
+    },
+    options,
+    runtimeOptions
+  );
+}
+function createStorageModule(gateway, runtimeOptions) {
+  return {
+    listStorageCatalogs(options) {
+      return callStorageEndpoint(gateway, storagePath("/storage/catalogs"), "GET", "raw", void 0, options, runtimeOptions);
+    },
+    createStorageCatalog(input, options) {
+      return callStorageEndpoint(gateway, storagePath("/storage/catalogs"), "POST", "raw", input, options, runtimeOptions);
+    },
+    updateStorageCatalog(id, input, options) {
+      return callStorageEndpoint(
+        gateway,
+        storagePath(withPathParam("/storage/catalogs/{id}", "id", id)),
+        "PATCH",
+        "raw",
+        input,
+        options,
+        runtimeOptions
+      );
+    },
+    deleteStorageCatalog(id, options) {
+      return callStorageEndpoint(
+        gateway,
+        storagePath(withPathParam("/storage/catalogs/{id}", "id", id)),
+        "DELETE",
+        "raw",
+        void 0,
+        options,
+        runtimeOptions
+      );
+    },
+    listStorageCredentials(options) {
+      return callStorageEndpoint(gateway, storagePath("/storage/credentials"), "GET", "raw", void 0, options, runtimeOptions);
+    },
+    createStorageUploadUrl(input, options) {
+      return callStorageEndpoint(
+        gateway,
+        storagePath("/storage/files/upload-url"),
+        "POST",
+        "athena",
+        input,
+        options,
+        runtimeOptions
+      );
+    },
+    createStorageUploadUrls(input, options) {
+      return callStorageEndpoint(
+        gateway,
+        storagePath("/storage/files/upload-urls"),
+        "POST",
+        "athena",
+        input,
+        options,
+        runtimeOptions
+      );
+    },
+    listStorageFiles(input, options) {
+      return callStorageEndpoint(gateway, storagePath("/storage/files/list"), "POST", "athena", input, options, runtimeOptions);
+    },
+    getStorageFile(fileId, options) {
+      return callStorageEndpoint(
+        gateway,
+        storagePath(withPathParam("/storage/files/{file_id}", "file_id", fileId)),
+        "GET",
+        "athena",
+        void 0,
+        options,
+        runtimeOptions
+      );
+    },
+    getStorageFileUrl(fileId, query, options) {
+      const path = appendQuery(
+        withPathParam("/storage/files/{file_id}/url", "file_id", fileId),
+        query
+      );
+      return callStorageEndpoint(gateway, storagePath(path), "GET", "athena", void 0, options, runtimeOptions);
+    },
+    getStorageFileProxy(fileId, query, options) {
+      const path = appendQuery(
+        withPathParam("/storage/files/{file_id}/proxy", "file_id", fileId),
+        query
+      );
+      return callStorageBinaryEndpoint(gateway, storagePath(path), "GET", options, runtimeOptions);
+    },
+    updateStorageFile(fileId, input, options) {
+      return callStorageEndpoint(
+        gateway,
+        storagePath(withPathParam("/storage/files/{file_id}", "file_id", fileId)),
+        "PATCH",
+        "athena",
+        input,
+        options,
+        runtimeOptions
+      );
+    },
+    deleteStorageFile(fileId, options) {
+      return callStorageEndpoint(
+        gateway,
+        storagePath(withPathParam("/storage/files/{file_id}", "file_id", fileId)),
+        "DELETE",
+        "athena",
+        void 0,
+        options,
+        runtimeOptions
+      );
+    },
+    setStorageFileVisibility(fileId, input, options) {
+      return callStorageEndpoint(
+        gateway,
+        storagePath(withPathParam("/storage/files/{file_id}/visibility", "file_id", fileId)),
+        "PATCH",
+        "athena",
+        input,
+        options,
+        runtimeOptions
+      );
+    },
+    deleteStorageFolder(input, options) {
+      return callStorageEndpoint(gateway, storagePath("/storage/folders/delete"), "POST", "athena", input, options, runtimeOptions);
+    },
+    moveStorageFolder(input, options) {
+      return callStorageEndpoint(gateway, storagePath("/storage/folders/move"), "POST", "athena", input, options, runtimeOptions);
+    }
+  };
+}
+
 // src/query-ast.ts
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var FILTER_OPERATORS = /* @__PURE__ */ new Set([
@@ -3506,7 +4184,7 @@ var BOOLEAN_SAFE_OPERATORS = /* @__PURE__ */ new Set([
   "ilike",
   "is"
 ]);
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isUuidString(value) {
@@ -3519,7 +4197,7 @@ function shouldUseUuidTextComparison(column, value) {
   return typeof value === "string" && isUuidString(value) && isUuidIdentifierColumn(column);
 }
 function isRelationSelectNode(value) {
-  return isRecord5(value) && isRecord5(value.select);
+  return isRecord6(value) && isRecord6(value.select);
 }
 function normalizeIdentifier(value, label) {
   const normalized = value.trim();
@@ -3575,7 +4253,7 @@ function compileRelationToken(key, node) {
   return `${prefix}${relationToken}(${nested})`;
 }
 function compileSelectShape(select) {
-  if (!isRecord5(select)) {
+  if (!isRecord6(select)) {
     throw new Error("findMany select must be an object");
   }
   const tokens = [];
@@ -3599,7 +4277,7 @@ function compileSelectShape(select) {
   return tokens.join(",");
 }
 function selectShapeUsesRelationSchema(select) {
-  if (!isRecord5(select)) {
+  if (!isRecord6(select)) {
     return false;
   }
   for (const rawValue of Object.values(select)) {
@@ -3617,7 +4295,7 @@ function selectShapeUsesRelationSchema(select) {
 }
 function compileColumnWhere(column, input) {
   const normalizedColumn = normalizeIdentifier(column, "where column");
-  if (!isRecord5(input)) {
+  if (!isRecord6(input)) {
     return [buildGatewayCondition("eq", normalizedColumn, input)];
   }
   const conditions = [];
@@ -3645,7 +4323,7 @@ function compileColumnWhere(column, input) {
   return conditions;
 }
 function compileBooleanExpressionTerms(clause, label) {
-  if (!isRecord5(clause)) {
+  if (!isRecord6(clause)) {
     throw new Error(`findMany where.${label} clauses must be objects`);
   }
   const entries = Object.entries(clause).filter(([, value]) => value !== void 0);
@@ -3654,7 +4332,7 @@ function compileBooleanExpressionTerms(clause, label) {
   }
   const [rawColumn, rawValue] = entries[0];
   const column = normalizeIdentifier(rawColumn, `where.${label} column`);
-  if (!isRecord5(rawValue)) {
+  if (!isRecord6(rawValue)) {
     return [`${column}.eq.${stringifyFilterValue(rawValue)}`];
   }
   const operatorEntries = Object.entries(rawValue).filter(([, value]) => value !== void 0);
@@ -3678,7 +4356,7 @@ function compileWhere(where) {
   if (where === void 0) {
     return void 0;
   }
-  if (!isRecord5(where)) {
+  if (!isRecord6(where)) {
     throw new Error("findMany where must be an object");
   }
   const conditions = [];
@@ -3728,7 +4406,7 @@ function compileOrderBy(orderBy) {
   if (orderBy === void 0) {
     return void 0;
   }
-  if (!isRecord5(orderBy)) {
+  if (!isRecord6(orderBy)) {
     throw new Error("findMany orderBy must be an object");
   }
   if ("column" in orderBy) {
@@ -3903,11 +4581,11 @@ function toFindManyAstOrder(order) {
     ascending: order.direction !== "descending"
   };
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeFindManyAstColumnPredicate(value) {
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     return {
       eq: value
     };
@@ -3931,7 +4609,7 @@ function normalizeFindManyAstBooleanOperand(clause) {
   return normalized;
 }
 function normalizeFindManyAstWhere(where) {
-  if (!where || !isRecord6(where)) {
+  if (!where || !isRecord7(where)) {
     return where;
   }
   const normalized = {};
@@ -3945,7 +4623,7 @@ function normalizeFindManyAstWhere(where) {
       );
       continue;
     }
-    if (key === "not" && isRecord6(value)) {
+    if (key === "not" && isRecord7(value)) {
       normalized.not = normalizeFindManyAstBooleanOperand(
         value
       );
@@ -3956,7 +4634,7 @@ function normalizeFindManyAstWhere(where) {
   return normalized;
 }
 function predicateRequiresUuidQueryFallback(column, value) {
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     return shouldUseUuidTextComparison(column, value);
   }
   const eqValue = value.eq;
@@ -3974,7 +4652,7 @@ function booleanOperandRequiresUuidQueryFallback(clause) {
   return false;
 }
 function findManyAstWhereRequiresLegacyTransport(where) {
-  if (!where || !isRecord6(where)) {
+  if (!where || !isRecord7(where)) {
     return false;
   }
   for (const [key, value] of Object.entries(where)) {
@@ -3989,7 +4667,7 @@ function findManyAstWhereRequiresLegacyTransport(where) {
       }
       continue;
     }
-    if (key === "not" && isRecord6(value)) {
+    if (key === "not" && isRecord7(value)) {
       if (booleanOperandRequiresUuidQueryFallback(value)) {
         return true;
       }
@@ -4191,7 +4869,7 @@ async function executeExperimentalRead(experimental, runner) {
     throw error;
   }
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function firstNonEmptyString2(...values) {
@@ -4203,8 +4881,8 @@ function firstNonEmptyString2(...values) {
   return void 0;
 }
 function resolveStructuredErrorPayload2(raw) {
-  if (!isRecord7(raw)) return null;
-  return isRecord7(raw.error) ? raw.error : raw;
+  if (!isRecord8(raw)) return null;
+  return isRecord8(raw.error) ? raw.error : raw;
 }
 function resolveStructuredErrorDetails(payload, message) {
   if (!payload || !("details" in payload)) {
@@ -4220,7 +4898,7 @@ function resolveStructuredErrorDetails(payload, message) {
   return details;
 }
 function createResultError(response, result, normalized) {
-  const rawRecord = isRecord7(response.raw) ? response.raw : null;
+  const rawRecord = isRecord8(response.raw) ? response.raw : null;
   const payload = resolveStructuredErrorPayload2(response.raw);
   const message = firstNonEmptyString2(
     response.error,
@@ -5683,7 +6361,7 @@ function createClientFromConfig(config) {
   };
   const query = createQueryBuilder(gateway, formatGatewayResult, config.experimental, queryTracer);
   const db = createDbModule({ from, rpc, query });
-  return {
+  const sdkClient = {
     from,
     db,
     rpc,
@@ -5691,6 +6369,14 @@ function createClientFromConfig(config) {
     verifyConnection: gateway.verifyConnection,
     auth: auth.auth
   };
+  if (config.experimental?.athenaStorageBackend) {
+    const storageClient = {
+      ...sdkClient,
+      storage: createStorageModule(gateway, config.experimental.storage)
+    };
+    return storageClient;
+  }
+  return sdkClient;
 }
 var DEFAULT_BACKEND = { type: "athena" };
 function toBackendConfig(b) {