@xylex-group/athena 2.6.0 → 2.7.0

package/dist/index.js

@@ -671,9 +671,16 @@ var getSessionCookie = (request, config) => {
   const { cookieName = "session_token", cookiePrefix = "athena-auth" } = config || {};
   const parsedCookie = parseCookies(cookies);
   const getCookie = (name) => parsedCookie.get(name) || parsedCookie.get(`${SECURE_COOKIE_PREFIX}${name}`);
-  const sessionToken = getCookie(`${cookiePrefix}.${cookieName}`) || getCookie(`${cookiePrefix}-${cookieName}`);
-  if (sessionToken) {
-    return sessionToken;
+  const candidateCookieNames = Array.from(/* @__PURE__ */ new Set([
+    cookieName,
+    cookieName.replace(/_/g, "-"),
+    cookieName.replace(/-/g, "_")
+  ])).filter(Boolean);
+  for (const candidateName of candidateCookieNames) {
+    const sessionToken = getCookie(`${cookiePrefix}.${candidateName}`) || getCookie(`${cookiePrefix}-${candidateName}`);
+    if (sessionToken) {
+      return sessionToken;
+    }
   }
   return null;
 };
@@ -796,7 +803,7 @@ var getCookieCache = async (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.6.0"
+  version: "2.7.0"
 };
 
 // src/sdk-version.ts
@@ -3371,6 +3378,344 @@ function createDbModule(input) {
   return db;
 }
 
+// src/storage/file.ts
+function createStorageFileModule(base, config = {}) {
+  const upload = async (input, options) => {
+    const sources = normalizeUploadSources(input);
+    validateUploadConstraints(sources, input);
+    const uploadRequests = sources.map((source, index) => {
+      const storageKey = resolveUploadStorageKey(input, source, index, options, config);
+      return {
+        source,
+        uploadRequest: {
+          s3_id: input.s3_id,
+          bucket: input.bucket,
+          storage_key: storageKey,
+          name: input.name ?? source.fileName,
+          original_name: input.original_name ?? source.fileName,
+          resource_id: input.resource_id ?? input.resourceId,
+          mime_type: input.mime_type ?? source.contentType,
+          content_type: input.content_type ?? source.contentType,
+          size_bytes: source.sizeBytes,
+          public: input.public,
+          metadata: input.metadata
+        }
+      };
+    });
+    input.onProgress?.(createProgressSnapshot("preparing", sources, 0, 0, 0));
+    const uploadUrls = uploadRequests.length === 1 ? [await base.createStorageUploadUrl(uploadRequests[0].uploadRequest, options)] : (await base.createStorageUploadUrls({ files: uploadRequests.map((request) => request.uploadRequest) }, options)).files;
+    const aggregateLoaded = new Array(uploadRequests.length).fill(0);
+    const uploaded = [];
+    for (let index = 0; index < uploadRequests.length; index += 1) {
+      const request = uploadRequests[index];
+      const uploadUrl = uploadUrls[index];
+      const response = await putUploadBody(uploadUrl.upload.url, request.source, input, options, (progress) => {
+        aggregateLoaded[index] = progress.loaded;
+        input.onProgress?.(createProgressSnapshot("uploading", sources, index, progress.loaded, sum(aggregateLoaded)));
+      });
+      uploaded.push({
+        file: uploadUrl.file,
+        upload: uploadUrl.upload,
+        source: request.source.source,
+        fileName: request.source.fileName,
+        storage_key: request.uploadRequest.storage_key,
+        response
+      });
+      aggregateLoaded[index] = request.source.sizeBytes;
+      input.onProgress?.(createProgressSnapshot("complete", sources, index, request.source.sizeBytes, sum(aggregateLoaded)));
+    }
+    return {
+      files: uploaded,
+      count: uploaded.length
+    };
+  };
+  const download = ((input, queryOrOptions, maybeOptions) => {
+    const { fileIds, query, options } = normalizeDownloadArgs(input, queryOrOptions, maybeOptions);
+    const downloads = fileIds.map((fileId) => base.getStorageFileProxy(fileId, query, options));
+    return Array.isArray(input) || isRecord5(input) && Array.isArray(input.fileIds) ? Promise.all(downloads) : downloads[0];
+  });
+  const deleteFile = ((input, options) => {
+    if (Array.isArray(input)) {
+      return Promise.all(input.map((fileId) => base.deleteStorageFile(fileId, options)));
+    }
+    return base.deleteStorageFile(input, options);
+  });
+  return {
+    upload,
+    download,
+    list(input, options) {
+      const prefix = resolveStoragePath(input.prefix ?? "", input, options, config);
+      return base.listStorageFiles(
+        {
+          s3_id: input.s3_id,
+          prefix
+        },
+        options
+      );
+    },
+    delete: deleteFile
+  };
+}
+function resolveStoragePath(path, input, options, config = {}) {
+  const context = createPathContext(input, options, config);
+  const prefixPath = input.prefixPath ?? config.prefixPath;
+  const prefix = typeof prefixPath === "function" ? prefixPath(context) : prefixPath;
+  return joinStoragePath(renderStorageTemplate(prefix ?? "", context), renderStorageTemplate(path, context));
+}
+function resolveUploadStorageKey(input, source, index, options, config) {
+  const explicitKey = input.storage_key ?? input.storageKey;
+  const keyTemplate = input.storageKeyTemplate;
+  const fallbackName = source.fileName;
+  const context = createPathContext(input, options, config);
+  const key = keyTemplate ? renderStorageTemplate(keyTemplate, {
+    ...context,
+    vars: {
+      ...context.vars,
+      index,
+      fileName: source.fileName,
+      name: source.fileName
+    }
+  }) : explicitKey ?? fallbackName;
+  return resolveStoragePath(key, input, options, config);
+}
+function normalizeUploadSources(input) {
+  const files = toArray(input.files);
+  if (files.length === 0) {
+    throw new Error("athena.storage.file.upload requires at least one file");
+  }
+  return files.map((source, index) => {
+    const fileName = input.fileName ?? sourceName(source) ?? `file-${index + 1}`;
+    const sizeBytes = sourceSize(source);
+    const contentType = input.content_type ?? input.mime_type ?? sourceContentType(source);
+    return {
+      source,
+      fileName,
+      sizeBytes,
+      contentType
+    };
+  });
+}
+function validateUploadConstraints(sources, input) {
+  const maxFiles = input.maxFiles ?? 1;
+  if (sources.length > maxFiles) {
+    throw new Error(`athena.storage.file.upload accepts at most ${maxFiles} file${maxFiles === 1 ? "" : "s"} for this call`);
+  }
+  const maxFileSizeBytes = input.maxFileSizeBytes ?? (input.maxFileSizeMb === void 0 ? void 0 : Math.floor(input.maxFileSizeMb * 1024 * 1024));
+  if (maxFileSizeBytes !== void 0) {
+    const tooLarge = sources.find((source) => source.sizeBytes > maxFileSizeBytes);
+    if (tooLarge) {
+      throw new Error(`athena.storage.file.upload rejected ${tooLarge.fileName}: file exceeds ${maxFileSizeBytes} bytes`);
+    }
+  }
+  const allowedExtensions = normalizeExtensions(input.allowedExtensions ?? input.extensions);
+  if (allowedExtensions.size > 0) {
+    const invalid = sources.find((source) => !allowedExtensions.has(fileExtension(source.fileName)));
+    if (invalid) {
+      throw new Error(`athena.storage.file.upload rejected ${invalid.fileName}: extension is not allowed`);
+    }
+  }
+}
+async function putUploadBody(url, source, input, options, onProgress) {
+  const headers = new Headers(input.uploadHeaders);
+  if (source.contentType && !headers.has("Content-Type")) {
+    headers.set("Content-Type", source.contentType);
+  }
+  if (typeof XMLHttpRequest !== "undefined") {
+    return putUploadBodyWithXhr(url, source, headers, options, onProgress);
+  }
+  onProgress({ loaded: 0 });
+  const response = await fetch(url, {
+    method: "PUT",
+    headers,
+    body: source.source,
+    signal: options?.signal
+  });
+  if (!response.ok) {
+    throw new Error(`athena.storage.file.upload failed with status ${response.status}`);
+  }
+  onProgress({ loaded: source.sizeBytes });
+  return response;
+}
+function putUploadBodyWithXhr(url, source, headers, options, onProgress) {
+  const Xhr = XMLHttpRequest;
+  if (Xhr === void 0) {
+    return Promise.reject(new Error("athena.storage.file.upload requires XMLHttpRequest in this runtime"));
+  }
+  return new Promise((resolve3, reject) => {
+    const xhr = new Xhr();
+    const abort = () => xhr.abort();
+    xhr.open("PUT", url);
+    headers.forEach((value, key) => xhr.setRequestHeader(key, value));
+    xhr.upload.onprogress = (event) => {
+      onProgress({ loaded: event.loaded });
+    };
+    xhr.onload = () => {
+      if (options?.signal) {
+        options.signal.removeEventListener("abort", abort);
+      }
+      if (xhr.status < 200 || xhr.status >= 300) {
+        reject(new Error(`athena.storage.file.upload failed with status ${xhr.status}`));
+        return;
+      }
+      onProgress({ loaded: source.sizeBytes });
+      resolve3(new Response(xhr.response, {
+        status: xhr.status,
+        statusText: xhr.statusText,
+        headers: parseXhrHeaders(xhr.getAllResponseHeaders())
+      }));
+    };
+    xhr.onerror = () => {
+      if (options?.signal) {
+        options.signal.removeEventListener("abort", abort);
+      }
+      reject(new Error("athena.storage.file.upload failed with a network error"));
+    };
+    xhr.onabort = () => {
+      if (options?.signal) {
+        options.signal.removeEventListener("abort", abort);
+      }
+      reject(new DOMException("Upload aborted", "AbortError"));
+    };
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        abort();
+        return;
+      }
+      options.signal.addEventListener("abort", abort, { once: true });
+    }
+    xhr.send(source.source);
+  });
+}
+function normalizeDownloadArgs(input, queryOrOptions, maybeOptions) {
+  if (typeof input === "string") {
+    return { fileIds: [input], query: queryOrOptions, options: maybeOptions };
+  }
+  if (Array.isArray(input)) {
+    return { fileIds: [...input], query: queryOrOptions, options: maybeOptions };
+  }
+  const downloadInput = input;
+  const { fileId, fileIds, ...query } = downloadInput;
+  return {
+    fileIds: fileIds ? [...fileIds] : fileId ? [fileId] : [],
+    query,
+    options: queryOrOptions
+  };
+}
+function createPathContext(input, options, config) {
+  const organizationId = input.organizationId ?? input.organization_id ?? options?.organizationId ?? void 0;
+  const userId = input.userId ?? input.user_id ?? options?.userId ?? void 0;
+  const resourceId = input.resourceId ?? input.resource_id ?? void 0;
+  const vars = {
+    ...config.vars ?? {},
+    ...input.vars ?? {}
+  };
+  if (organizationId !== void 0) {
+    vars.organizationId = organizationId;
+    vars.organization_id = organizationId;
+  }
+  if (userId !== void 0) {
+    vars.userId = userId;
+    vars.user_id = userId;
+  }
+  if (resourceId !== void 0) {
+    vars.resourceId = resourceId;
+    vars.resource_id = resourceId;
+  }
+  return {
+    vars,
+    env: {
+      ...readProcessEnv(),
+      ...config.env ?? {},
+      ...input.env ?? {}
+    },
+    organizationId,
+    organization_id: organizationId,
+    userId,
+    user_id: userId,
+    resourceId,
+    resource_id: resourceId
+  };
+}
+function renderStorageTemplate(template, context) {
+  return template.replace(/\$\{([^}]+)\}|\{([^}]+)\}/g, (_match, shellToken, braceToken) => {
+    const token = (shellToken ?? braceToken ?? "").trim();
+    if (!token) return "";
+    const value = resolveTemplateToken(token, context);
+    return value === void 0 || value === null ? "" : String(value);
+  });
+}
+function resolveTemplateToken(token, context) {
+  if (token.startsWith("env.")) {
+    return context.env[token.slice(4)];
+  }
+  if (token in context.vars) {
+    return context.vars[token];
+  }
+  return context.env[token];
+}
+function joinStoragePath(...parts) {
+  return parts.map((part) => part.trim().replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+}
+function toArray(files) {
+  if (isUploadSource(files)) return [files];
+  return Array.from(files);
+}
+function isUploadSource(value) {
+  return value instanceof Blob || value instanceof ArrayBuffer || value instanceof Uint8Array;
+}
+function sourceName(source) {
+  return isRecord5(source) && typeof source.name === "string" && source.name.trim() ? source.name.trim() : void 0;
+}
+function sourceSize(source) {
+  if (source instanceof Blob) return source.size;
+  return source.byteLength;
+}
+function sourceContentType(source) {
+  return source instanceof Blob && source.type.trim() ? source.type.trim() : void 0;
+}
+function normalizeExtensions(extensions) {
+  return new Set((extensions ?? []).map((extension) => extension.replace(/^\./, "").toLowerCase()).filter(Boolean));
+}
+function fileExtension(fileName) {
+  const lastDot = fileName.lastIndexOf(".");
+  return lastDot === -1 ? "" : fileName.slice(lastDot + 1).toLowerCase();
+}
+function createProgressSnapshot(phase, sources, fileIndex, loaded, aggregateLoaded) {
+  const total = sources[fileIndex]?.sizeBytes ?? 0;
+  const aggregateTotal = sources.reduce((totalBytes, source) => totalBytes + source.sizeBytes, 0);
+  return {
+    phase,
+    fileIndex,
+    fileCount: sources.length,
+    fileName: sources[fileIndex]?.fileName ?? "",
+    loaded,
+    total,
+    percent: total > 0 ? Math.round(loaded / total * 100) : 100,
+    aggregateLoaded,
+    aggregateTotal,
+    aggregatePercent: aggregateTotal > 0 ? Math.round(aggregateLoaded / aggregateTotal * 100) : 100
+  };
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function parseXhrHeaders(raw) {
+  const headers = new Headers();
+  for (const line of raw.trim().split(/[\r\n]+/)) {
+    const index = line.indexOf(":");
+    if (index === -1) continue;
+    headers.set(line.slice(0, index).trim(), line.slice(index + 1).trim());
+  }
+  return headers;
+}
+function readProcessEnv() {
+  const processLike = globalThis.process;
+  return processLike?.env ?? {};
+}
+function isRecord5(value) {
+  return Boolean(value) && typeof value === "object";
+}
+
 // src/storage/module.ts
 var storageSdkManifest = {
   namespace: "storage",
@@ -3579,7 +3924,7 @@ var AthenaStorageError = class extends Error {
     };
   }
 };
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function causeToString(cause) {
@@ -3694,7 +4039,7 @@ function withPathParam(path, name, value) {
   return path.replace(`{${name}}`, encodeURIComponent(value));
 }
 function resolveErrorMessage3(payload, fallback) {
-  if (isRecord5(payload)) {
+  if (isRecord6(payload)) {
     const message = payload.message ?? payload.error ?? payload.details;
     if (typeof message === "string" && message.trim()) {
       return message.trim();
@@ -3706,12 +4051,12 @@ function resolveErrorMessage3(payload, fallback) {
   return fallback;
 }
 function resolveErrorHint2(payload) {
-  if (!isRecord5(payload)) return void 0;
+  if (!isRecord6(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;
+  if (!isRecord6(payload)) return void 0;
   const cause = payload.cause ?? payload.reason;
   return typeof cause === "string" && cause.trim() ? cause.trim() : void 0;
 }
@@ -3830,7 +4175,7 @@ async function callStorageEndpoint(gateway, endpoint, method, envelope, payload,
     );
   }
   if (envelope === "athena") {
-    if (!isRecord5(parsedBody.parsed) || !("data" in parsedBody.parsed)) {
+    if (!isRecord6(parsedBody.parsed) || !("data" in parsedBody.parsed)) {
       return rejectStorageError(
         {
           code: "INVALID_ATHENA_ENVELOPE",
@@ -3938,81 +4283,260 @@ async function callStorageBinaryEndpoint(gateway, endpoint, method, options, run
     runtimeOptions
   );
 }
-function createStorageModule(gateway, runtimeOptions) {
+function isBlobBody(body) {
+  return typeof Blob !== "undefined" && body instanceof Blob;
+}
+function isReadableStreamBody(body) {
+  return typeof ReadableStream !== "undefined" && body instanceof ReadableStream;
+}
+async function putPresignedUploadBody(uploadUrl, uploadHeaders, body, options) {
+  const headers = new Headers(uploadHeaders);
+  Object.entries(options?.headers ?? {}).forEach(([key, value]) => headers.set(key, value));
+  if (!headers.has("Content-Type") && isBlobBody(body) && body.type) {
+    headers.set("Content-Type", body.type);
+  }
+  const init = {
+    method: "PUT",
+    headers,
+    body,
+    signal: options?.signal
+  };
+  if (isReadableStreamBody(body)) {
+    init.duplex = "half";
+  }
+  return fetch(uploadUrl, init);
+}
+function attachManagedUpload(upload) {
+  const headers = {};
   return {
+    ...upload,
+    method: "PUT",
+    headers,
+    expiresAt: upload.expires_at,
+    put(body, options) {
+      return putPresignedUploadBody(upload.url, headers, body, options);
+    }
+  };
+}
+function attachUploadHelper(response) {
+  return {
+    ...response,
+    upload: attachManagedUpload(response.upload)
+  };
+}
+function attachUploadHelpers(response) {
+  return {
+    files: response.files.map(attachUploadHelper)
+  };
+}
+function normalizeUploadUrlRequest(input) {
+  const s3_id = input.s3_id ?? input.s3Id;
+  const storage_key = input.storage_key ?? input.storageKey;
+  if (!s3_id?.trim()) {
+    throw new Error("athena.storage.file.upload requires s3_id or s3Id");
+  }
+  if (!storage_key?.trim()) {
+    throw new Error("athena.storage.file.upload requires storage_key or storageKey");
+  }
+  const fileName = input.fileName?.trim();
+  const originalName = input.originalName?.trim();
+  return {
+    s3_id,
+    bucket: input.bucket,
+    storage_key,
+    name: input.name ?? fileName,
+    original_name: input.original_name ?? originalName ?? fileName,
+    resource_id: input.resource_id ?? input.resourceId,
+    mime_type: input.mime_type ?? input.mimeType,
+    content_type: input.content_type ?? input.contentType,
+    size_bytes: input.size_bytes ?? input.sizeBytes,
+    file_id: input.file_id ?? input.fileId,
+    public: input.public,
+    visibility: input.visibility,
+    metadata: input.metadata
+  };
+}
+async function callStorageUploadBinaryEndpoint(gateway, endpoint, body, 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 PUT ${endpoint} failed before sending the request`,
+        status: isAthenaGatewayError(error) ? error.status : 0,
+        endpoint,
+        method: "PUT",
+        raw: error,
+        requestId: isAthenaGatewayError(error) ? error.requestId : void 0,
+        hint: isAthenaGatewayError(error) ? error.hint : void 0,
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  delete headers["Content-Type"];
+  delete headers["content-type"];
+  if (isBlobBody(body) && body.type) {
+    headers["Content-Type"] = body.type;
+  }
+  const requestInit = {
+    method: "PUT",
+    headers,
+    body,
+    signal: options?.signal
+  };
+  if (isReadableStreamBody(body)) {
+    requestInit.duplex = "half";
+  }
+  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 PUT ${endpoint}: ${message}`,
+        status: 0,
+        endpoint,
+        method: "PUT",
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  let rawText;
+  try {
+    rawText = await response.text();
+  } catch (error) {
+    return rejectStorageError(
+      {
+        code: "NETWORK_ERROR",
+        message: `Athena storage PUT ${endpoint} response body could not be read`,
+        status: response.status,
+        endpoint,
+        method: "PUT",
+        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 PUT ${endpoint} returned malformed JSON`,
+        status: response.status,
+        endpoint,
+        method: "PUT",
+        requestId,
+        raw: parsedBody.parsed
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  if (!response.ok) {
+    return rejectStorageError(
+      {
+        code: "HTTP_ERROR",
+        message: resolveErrorMessage3(
+          parsedBody.parsed,
+          `Athena storage PUT ${endpoint} failed with status ${response.status}`
+        ),
+        status: response.status,
+        endpoint,
+        method: "PUT",
+        requestId,
+        hint: resolveErrorHint2(parsedBody.parsed),
+        cause: resolveErrorCause(parsedBody.parsed),
+        raw: parsedBody.parsed
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  if (!isRecord6(parsedBody.parsed) || !("data" in parsedBody.parsed)) {
+    return rejectStorageError(
+      {
+        code: "INVALID_ATHENA_ENVELOPE",
+        message: `Athena storage PUT ${endpoint} returned an invalid Athena envelope`,
+        status: response.status,
+        endpoint,
+        method: "PUT",
+        requestId,
+        raw: parsedBody.parsed
+      },
+      options,
+      runtimeOptions
+    );
+  }
+  return parsedBody.parsed.data;
+}
+function createStorageModule(gateway, runtimeOptions) {
+  const callRaw = (path, method, payload, options) => callStorageEndpoint(
+    gateway,
+    storagePath(path),
+    method,
+    "raw",
+    payload,
+    options,
+    runtimeOptions
+  );
+  const callAthena2 = (path, method, payload, options) => callStorageEndpoint(
+    gateway,
+    storagePath(path),
+    method,
+    "athena",
+    payload,
+    options,
+    runtimeOptions
+  );
+  const base = {
     listStorageCatalogs(options) {
-      return callStorageEndpoint(gateway, storagePath("/storage/catalogs"), "GET", "raw", void 0, options, runtimeOptions);
+      return callRaw("/storage/catalogs", "GET", void 0, options);
     },
     createStorageCatalog(input, options) {
-      return callStorageEndpoint(gateway, storagePath("/storage/catalogs"), "POST", "raw", input, options, runtimeOptions);
+      return callRaw("/storage/catalogs", "POST", input, options);
     },
     updateStorageCatalog(id, input, options) {
-      return callStorageEndpoint(
-        gateway,
-        storagePath(withPathParam("/storage/catalogs/{id}", "id", id)),
-        "PATCH",
-        "raw",
-        input,
-        options,
-        runtimeOptions
-      );
+      return callRaw(withPathParam("/storage/catalogs/{id}", "id", id), "PATCH", input, options);
     },
     deleteStorageCatalog(id, options) {
-      return callStorageEndpoint(
-        gateway,
-        storagePath(withPathParam("/storage/catalogs/{id}", "id", id)),
-        "DELETE",
-        "raw",
-        void 0,
-        options,
-        runtimeOptions
-      );
+      return callRaw(withPathParam("/storage/catalogs/{id}", "id", id), "DELETE", void 0, options);
     },
     listStorageCredentials(options) {
-      return callStorageEndpoint(gateway, storagePath("/storage/credentials"), "GET", "raw", void 0, options, runtimeOptions);
+      return callRaw("/storage/credentials", "GET", void 0, options);
     },
     createStorageUploadUrl(input, options) {
-      return callStorageEndpoint(
-        gateway,
-        storagePath("/storage/files/upload-url"),
-        "POST",
-        "athena",
-        input,
-        options,
-        runtimeOptions
-      );
+      return callAthena2("/storage/files/upload-url", "POST", input, options);
     },
     createStorageUploadUrls(input, options) {
-      return callStorageEndpoint(
-        gateway,
-        storagePath("/storage/files/upload-urls"),
-        "POST",
-        "athena",
-        input,
-        options,
-        runtimeOptions
-      );
+      return callAthena2("/storage/files/upload-urls", "POST", input, options);
     },
     listStorageFiles(input, options) {
-      return callStorageEndpoint(gateway, storagePath("/storage/files/list"), "POST", "athena", input, options, runtimeOptions);
+      return callAthena2("/storage/files/list", "POST", input, options);
     },
     getStorageFile(fileId, options) {
-      return callStorageEndpoint(
-        gateway,
-        storagePath(withPathParam("/storage/files/{file_id}", "file_id", fileId)),
-        "GET",
-        "athena",
-        void 0,
-        options,
-        runtimeOptions
-      );
+      return callAthena2(withPathParam("/storage/files/{file_id}", "file_id", fileId), "GET", void 0, options);
     },
     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);
+      return callAthena2(path, "GET", void 0, options);
     },
     getStorageFileProxy(fileId, query, options) {
       const path = appendQuery(
@@ -4022,45 +4546,244 @@ function createStorageModule(gateway, runtimeOptions) {
       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
-      );
+      return callAthena2(withPathParam("/storage/files/{file_id}", "file_id", fileId), "PATCH", input, options);
     },
     deleteStorageFile(fileId, options) {
-      return callStorageEndpoint(
-        gateway,
-        storagePath(withPathParam("/storage/files/{file_id}", "file_id", fileId)),
-        "DELETE",
-        "athena",
-        void 0,
-        options,
-        runtimeOptions
-      );
+      return callAthena2(withPathParam("/storage/files/{file_id}", "file_id", fileId), "DELETE", void 0, options);
     },
     setStorageFileVisibility(fileId, input, options) {
-      return callStorageEndpoint(
+      return callAthena2(withPathParam("/storage/files/{file_id}/visibility", "file_id", fileId), "PATCH", input, options);
+    },
+    deleteStorageFolder(input, options) {
+      return callAthena2("/storage/folders/delete", "POST", input, options);
+    },
+    moveStorageFolder(input, options) {
+      return callAthena2("/storage/folders/move", "POST", input, options);
+    }
+  };
+  const fileFacade = createStorageFileModule(base, runtimeOptions);
+  const fileUpload = ((input, options) => {
+    if (isRecord6(input) && "files" in input) {
+      return fileFacade.upload(input, options);
+    }
+    return base.createStorageUploadUrl(
+      normalizeUploadUrlRequest(input),
+      options
+    ).then(attachUploadHelper);
+  });
+  const fileDelete = ((input, options) => fileFacade.delete(input, options));
+  const file = {
+    ...fileFacade,
+    upload: fileUpload,
+    uploadMany(input, options) {
+      return base.createStorageUploadUrls(
+        { files: input.files.map(normalizeUploadUrlRequest) },
+        options
+      ).then(attachUploadHelpers);
+    },
+    confirmUpload(fileId, input, options) {
+      return callAthena2(withPathParam("/storage/files/{file_id}/confirm-upload", "file_id", fileId), "POST", input ?? {}, options);
+    },
+    uploadBinary(fileId, body, options) {
+      return callStorageUploadBinaryEndpoint(
         gateway,
-        storagePath(withPathParam("/storage/files/{file_id}/visibility", "file_id", fileId)),
-        "PATCH",
-        "athena",
-        input,
+        storagePath(withPathParam("/storage/files/{file_id}/upload", "file_id", fileId)),
+        body,
         options,
         runtimeOptions
       );
     },
-    deleteStorageFolder(input, options) {
-      return callStorageEndpoint(gateway, storagePath("/storage/folders/delete"), "POST", "athena", input, options, runtimeOptions);
+    search(input, options) {
+      return callAthena2("/storage/files/search", "POST", input, options);
     },
-    moveStorageFolder(input, options) {
-      return callStorageEndpoint(gateway, storagePath("/storage/folders/move"), "POST", "athena", input, options, runtimeOptions);
+    get(fileId, options) {
+      return base.getStorageFile(fileId, options);
+    },
+    update(fileId, input, options) {
+      return base.updateStorageFile(fileId, input, options);
+    },
+    delete: fileDelete,
+    deleteMany(input, options) {
+      return callAthena2("/storage/files/delete-many", "POST", input, options);
+    },
+    updateMany(input, options) {
+      return callAthena2("/storage/files/update-many", "POST", input, options);
+    },
+    restore(fileId, options) {
+      return callAthena2(withPathParam("/storage/files/{file_id}/restore", "file_id", fileId), "POST", {}, options);
+    },
+    purge(fileId, options) {
+      return callAthena2(withPathParam("/storage/files/{file_id}/purge", "file_id", fileId), "DELETE", void 0, options);
+    },
+    copy(fileId, input, options) {
+      return callAthena2(withPathParam("/storage/files/{file_id}/copy", "file_id", fileId), "POST", input, options);
+    },
+    url(fileId, query, options) {
+      return base.getStorageFileUrl(fileId, query, options);
+    },
+    publicUrl(fileId, options) {
+      return callAthena2(withPathParam("/storage/files/{file_id}/public-url", "file_id", fileId), "GET", void 0, options);
+    },
+    proxy(fileId, query, options) {
+      return base.getStorageFileProxy(fileId, query, options);
+    },
+    visibility: {
+      set(fileId, input, options) {
+        return base.setStorageFileVisibility(fileId, input, options);
+      },
+      setMany(input, options) {
+        return callAthena2("/storage/files/visibility-many", "POST", input, options);
+      }
+    }
+  };
+  const credentials = {
+    list(options) {
+      return base.listStorageCredentials(options);
+    }
+  };
+  const catalog = {
+    list(options) {
+      return base.listStorageCatalogs(options);
+    },
+    create(input, options) {
+      return base.createStorageCatalog(input, options);
+    },
+    update(id, input, options) {
+      return base.updateStorageCatalog(id, input, options);
+    },
+    delete(id, options) {
+      return base.deleteStorageCatalog(id, options);
+    }
+  };
+  const folder = {
+    list(input, options) {
+      return callAthena2("/storage/folders/list", "POST", input, options);
+    },
+    tree(input, options) {
+      return callAthena2("/storage/folders/tree", "POST", input, options);
+    },
+    delete(input, options) {
+      return base.deleteStorageFolder(input, options);
+    },
+    move(input, options) {
+      return base.moveStorageFolder(input, options);
+    }
+  };
+  const permission = {
+    list(input, options) {
+      return callAthena2("/storage/permissions/list", "POST", input, options);
+    },
+    grant(input, options) {
+      return callAthena2("/storage/permissions/grant", "POST", input, options);
+    },
+    revoke(input, options) {
+      return callAthena2("/storage/permissions/revoke", "POST", input, options);
+    },
+    check(input, options) {
+      return callAthena2("/storage/permissions/check", "POST", input, options);
     }
   };
+  const objectFolder = {
+    create(input, options) {
+      return callAthena2("/storage/objects/folder", "POST", input, options);
+    },
+    delete(input, options) {
+      return callAthena2("/storage/objects/folder/delete", "POST", input, options);
+    },
+    rename(input, options) {
+      return callAthena2("/storage/objects/folder/rename", "POST", input, options);
+    }
+  };
+  const object = {
+    list(input, options) {
+      return callAthena2("/storage/objects", "POST", input, options);
+    },
+    head(input, options) {
+      return callAthena2("/storage/objects/head", "POST", input, options);
+    },
+    exists(input, options) {
+      return callAthena2("/storage/objects/exists", "POST", input, options);
+    },
+    validate(input, options) {
+      return callAthena2("/storage/objects/validate", "POST", input, options);
+    },
+    update(input, options) {
+      return callAthena2("/storage/objects/update", "POST", input, options);
+    },
+    copy(input, options) {
+      return callAthena2("/storage/objects/copy", "POST", input, options);
+    },
+    url(input, options) {
+      return callAthena2("/storage/objects/url", "POST", input, options);
+    },
+    publicUrl(input, options) {
+      return callAthena2("/storage/objects/public-url", "POST", input, options);
+    },
+    delete(input, options) {
+      return callAthena2("/storage/objects/delete", "POST", input, options);
+    },
+    uploadUrl(input, options) {
+      return callAthena2("/storage/objects/upload-url", "POST", input, options);
+    },
+    folder: objectFolder
+  };
+  const bucket = {
+    list(input, options) {
+      return callAthena2("/storage/buckets/list", "POST", input, options);
+    },
+    create(input, options) {
+      return callAthena2("/storage/buckets/create", "POST", input, options);
+    },
+    delete(input, options) {
+      return callAthena2("/storage/buckets/delete", "POST", input, options);
+    },
+    cors: {
+      get(input, options) {
+        return callAthena2("/storage/buckets/cors", "POST", input, options);
+      },
+      set(input, options) {
+        return callAthena2("/storage/buckets/cors/set", "POST", input, options);
+      },
+      delete(input, options) {
+        return callAthena2("/storage/buckets/cors/delete", "POST", input, options);
+      }
+    }
+  };
+  const multipart = {
+    create(input, options) {
+      return callAthena2("/storage/multipart/create", "POST", input, options);
+    },
+    signPart(input, options) {
+      return callAthena2("/storage/multipart/sign-part", "POST", input, options);
+    },
+    complete(input, options) {
+      return callAthena2("/storage/multipart/complete", "POST", input, options);
+    },
+    abort(input, options) {
+      return callAthena2("/storage/multipart/abort", "POST", input, options);
+    },
+    listParts(input, options) {
+      return callAthena2("/storage/multipart/list-parts", "POST", input, options);
+    }
+  };
+  const audit = {
+    list(input, options) {
+      return callAthena2("/storage/audit/list", "POST", input, options);
+    }
+  };
+  return {
+    ...base,
+    credentials,
+    catalog,
+    file,
+    folder,
+    permission,
+    object,
+    bucket,
+    multipart,
+    audit,
+    delete: file.delete
+  };
 }
 
 // src/query-ast.ts
@@ -4090,7 +4813,7 @@ var BOOLEAN_SAFE_OPERATORS = /* @__PURE__ */ new Set([
   "ilike",
   "is"
 ]);
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isUuidString(value) {
@@ -4103,7 +4826,7 @@ function shouldUseUuidTextComparison(column, value) {
   return typeof value === "string" && isUuidString(value) && isUuidIdentifierColumn(column);
 }
 function isRelationSelectNode(value) {
-  return isRecord6(value) && isRecord6(value.select);
+  return isRecord7(value) && isRecord7(value.select);
 }
 function normalizeIdentifier(value, label) {
   const normalized = value.trim();
@@ -4159,7 +4882,7 @@ function compileRelationToken(key, node) {
   return `${prefix}${relationToken}(${nested})`;
 }
 function compileSelectShape(select) {
-  if (!isRecord6(select)) {
+  if (!isRecord7(select)) {
     throw new Error("findMany select must be an object");
   }
   const tokens = [];
@@ -4183,7 +4906,7 @@ function compileSelectShape(select) {
   return tokens.join(",");
 }
 function selectShapeUsesRelationSchema(select) {
-  if (!isRecord6(select)) {
+  if (!isRecord7(select)) {
     return false;
   }
   for (const rawValue of Object.values(select)) {
@@ -4201,7 +4924,7 @@ function selectShapeUsesRelationSchema(select) {
 }
 function compileColumnWhere(column, input) {
   const normalizedColumn = normalizeIdentifier(column, "where column");
-  if (!isRecord6(input)) {
+  if (!isRecord7(input)) {
     return [buildGatewayCondition("eq", normalizedColumn, input)];
   }
   const conditions = [];
@@ -4229,7 +4952,7 @@ function compileColumnWhere(column, input) {
   return conditions;
 }
 function compileBooleanExpressionTerms(clause, label) {
-  if (!isRecord6(clause)) {
+  if (!isRecord7(clause)) {
     throw new Error(`findMany where.${label} clauses must be objects`);
   }
   const entries = Object.entries(clause).filter(([, value]) => value !== void 0);
@@ -4238,7 +4961,7 @@ function compileBooleanExpressionTerms(clause, label) {
   }
   const [rawColumn, rawValue] = entries[0];
   const column = normalizeIdentifier(rawColumn, `where.${label} column`);
-  if (!isRecord6(rawValue)) {
+  if (!isRecord7(rawValue)) {
     return [`${column}.eq.${stringifyFilterValue(rawValue)}`];
   }
   const operatorEntries = Object.entries(rawValue).filter(([, value]) => value !== void 0);
@@ -4262,7 +4985,7 @@ function compileWhere(where) {
   if (where === void 0) {
     return void 0;
   }
-  if (!isRecord6(where)) {
+  if (!isRecord7(where)) {
     throw new Error("findMany where must be an object");
   }
   const conditions = [];
@@ -4312,7 +5035,7 @@ function compileOrderBy(orderBy) {
   if (orderBy === void 0) {
     return void 0;
   }
-  if (!isRecord6(orderBy)) {
+  if (!isRecord7(orderBy)) {
     throw new Error("findMany orderBy must be an object");
   }
   if ("column" in orderBy) {
@@ -4487,11 +5210,11 @@ function toFindManyAstOrder(order) {
     ascending: order.direction !== "descending"
   };
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeFindManyAstColumnPredicate(value) {
-  if (!isRecord7(value)) {
+  if (!isRecord8(value)) {
     return {
       eq: value
     };
@@ -4515,7 +5238,7 @@ function normalizeFindManyAstBooleanOperand(clause) {
   return normalized;
 }
 function normalizeFindManyAstWhere(where) {
-  if (!where || !isRecord7(where)) {
+  if (!where || !isRecord8(where)) {
     return where;
   }
   const normalized = {};
@@ -4529,7 +5252,7 @@ function normalizeFindManyAstWhere(where) {
       );
       continue;
     }
-    if (key === "not" && isRecord7(value)) {
+    if (key === "not" && isRecord8(value)) {
       normalized.not = normalizeFindManyAstBooleanOperand(
         value
       );
@@ -4540,7 +5263,7 @@ function normalizeFindManyAstWhere(where) {
   return normalized;
 }
 function predicateRequiresUuidQueryFallback(column, value) {
-  if (!isRecord7(value)) {
+  if (!isRecord8(value)) {
     return shouldUseUuidTextComparison(column, value);
   }
   const eqValue = value.eq;
@@ -4558,7 +5281,7 @@ function booleanOperandRequiresUuidQueryFallback(clause) {
   return false;
 }
 function findManyAstWhereRequiresLegacyTransport(where) {
-  if (!where || !isRecord7(where)) {
+  if (!where || !isRecord8(where)) {
     return false;
   }
   for (const [key, value] of Object.entries(where)) {
@@ -4573,7 +5296,7 @@ function findManyAstWhereRequiresLegacyTransport(where) {
       }
       continue;
     }
-    if (key === "not" && isRecord7(value)) {
+    if (key === "not" && isRecord8(value)) {
       if (booleanOperandRequiresUuidQueryFallback(value)) {
         return true;
       }
@@ -4775,7 +5498,7 @@ async function executeExperimentalRead(experimental, runner) {
     throw error;
   }
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function firstNonEmptyString2(...values) {
@@ -4787,8 +5510,8 @@ function firstNonEmptyString2(...values) {
   return void 0;
 }
 function resolveStructuredErrorPayload2(raw) {
-  if (!isRecord8(raw)) return null;
-  return isRecord8(raw.error) ? raw.error : raw;
+  if (!isRecord9(raw)) return null;
+  return isRecord9(raw.error) ? raw.error : raw;
 }
 function resolveStructuredErrorDetails(payload, message) {
   if (!payload || !("details" in payload)) {
@@ -4804,7 +5527,7 @@ function resolveStructuredErrorDetails(payload, message) {
   return details;
 }
 function createResultError(response, result, normalized) {
-  const rawRecord = isRecord8(response.raw) ? response.raw : null;
+  const rawRecord = isRecord9(response.raw) ? response.raw : null;
   const payload = resolveStructuredErrorPayload2(response.raw);
   const message = firstNonEmptyString2(
     response.error,
@@ -7007,7 +7730,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -7016,7 +7739,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord9(source)) {
+  if (!isRecord10(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -8353,15 +9076,15 @@ function readCookieFromHeaders(headers, name) {
   }
   return parseCookies(cookieHeader).get(name);
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function resolveSessionCandidate(value) {
-  if (!isRecord10(value)) {
+  if (!isRecord11(value)) {
     return null;
   }
-  const session = isRecord10(value.session) ? value.session : void 0;
-  const user = isRecord10(value.user) ? value.user : void 0;
+  const session = isRecord11(value.session) ? value.session : void 0;
+  const user = isRecord11(value.user) ? value.user : void 0;
   if (session && typeof session.token === "string" && session.token.length > 0 && user) {
     return {
       session,
@@ -8371,7 +9094,7 @@ function resolveSessionCandidate(value) {
   return null;
 }
 function inferSessionPair(returned) {
-  return resolveSessionCandidate(returned) ?? (isRecord10(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord10(returned) ? resolveSessionCandidate(returned.session) : null);
+  return resolveSessionCandidate(returned) ?? (isRecord11(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord11(returned) ? resolveSessionCandidate(returned.session) : null);
 }
 function resolveResponseHeaders(ctx) {
   if (ctx.context.responseHeaders instanceof Headers) {