@wix/cli/build/chunk-JQOAY3IH.js

CLI tool for building Wix sites and applications

import { createRequire as _createRequire } from 'node:module';
const require = _createRequire(import.meta.url);
import {
  useHttpClient
} from "./chunk-FYLO6WOU.js";
import {
  usePanoramaMethodLogger
} from "./chunk-3B6VL2WO.js";
import {
  isHttpApplicationError,
  isHttpError,
  pRetry,
  resolveUrl,
  serializer,
  toURLSearchParams
} from "./chunk-CCWE4DS6.js";
import {
  require_index_node
} from "./chunk-U5H3SP3I.js";
import {
  require_react
} from "./chunk-QNHANFRW.js";
import {
  getTestOverrides
} from "./chunk-XZUGLEBK.js";
import {
  external_exports
} from "./chunk-SDLCFZRL.js";
import {
  CliError,
  CliErrorCode
} from "./chunk-CO5A7CZG.js";
import {
  __toESM,
  init_esm_shims
} from "./chunk-EXLZF52D.js";

// ../backend-as-a-service-client/src/useBackendAsAServiceClient.ts
init_esm_shims();
var import_react = __toESM(require_react(), 1);

// ../cli-http-client/src/fetch-error.ts
init_esm_shims();
var import_http_client = __toESM(require_index_node(), 1);
async function createHttpErrorFromFetch(originalResponse) {
  const res = originalResponse.clone();
  return (0, import_http_client.createHttpError)({
    name: "Error",
    message: `Request failed with status code ${res.status}`,
    response: {
      config: {},
      data: await res.text(),
      status: res.status,
      statusText: res.statusText,
      headers: Object.fromEntries(res.headers)
    },
    code: res.statusText,
    config: {},
    toJSON: () => res,
    __CANCEL__: false
  });
}

// ../backend-as-a-service-client/src/backend-as-a-service-client.ts
init_esm_shims();
import { randomUUID } from "node:crypto";

// ../../node_modules/@wix/ambassador-velo-backend-v1-app-deployment/es/build/http.impl.js
init_esm_shims();
var _appDeployment = {
  createdDate: "google.protobuf.Timestamp",
  updatedDate: "google.protobuf.Timestamp"
};
var _completeAppDeploymentRequest = { appDeployment: "_appDeployment" };
var _completeAppDeploymentResponse = { appDeployment: "_appDeployment" };
var _createAppDeploymentRequest = { appDeployment: "_appDeployment" };
var _createAppDeploymentResponse = { appDeployment: "_appDeployment" };
function resolveWixVeloBackendV1AppDeploymentManagementUrl(opts) {
  var domainToMappings = {
    "manage._base_domain_": [
      {
        srcPath: "/_api/wix-code-app-deployments",
        destPath: ""
      }
    ]
  };
  return resolveUrl(Object.assign(opts, { domainToMappings }));
}
function createAppDeployment(payload) {
  var _a = serializer(_createAppDeploymentRequest, { _appDeployment }), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_createAppDeploymentResponse, {
    _appDeployment
  }).fromJSON;
  function __createAppDeployment(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v1.app_deployment",
      method: "POST",
      methodFqn: "wix.velo.backend.v1.AppDeploymentManagement.CreateAppDeployment",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveWixVeloBackendV1AppDeploymentManagementUrl({
        protoPath: "/v1/app-projects/{appDeployment.appProjectId}/app-deployments",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __createAppDeployment.fromReq = fromReq;
  __createAppDeployment.__isAmbassador = true;
  return __createAppDeployment;
}
function completeAppDeployment(payload) {
  var _a = serializer(_completeAppDeploymentRequest, { _appDeployment }), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_completeAppDeploymentResponse, {
    _appDeployment
  }).fromJSON;
  function __completeAppDeployment(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v1.app_deployment",
      method: "POST",
      methodFqn: "wix.velo.backend.v1.AppDeploymentManagement.CompleteAppDeployment",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveWixVeloBackendV1AppDeploymentManagementUrl({
        protoPath: "/v1/app-projects/{appDeployment.appProjectId}/app-deployments/{appDeployment.id}/complete",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __completeAppDeployment.fromReq = fromReq;
  __completeAppDeployment.__isAmbassador = true;
  return __completeAppDeployment;
}

// ../../node_modules/@wix/ambassador-velo-backend-v1-app-project/build/es/http.impl.js
init_esm_shims();
var _appProject = {
  createdDate: "google.protobuf.Timestamp",
  updatedDate: "google.protobuf.Timestamp",
  customDomain: "_customDomain"
};
var _createAppProjectRequest = { appProject: "_appProject" };
var _createAppProjectResponse = { appProject: "_appProject" };
var _customDomain = { connectionDate: "google.protobuf.Timestamp" };
var _getAppProjectRequest = {};
var _getAppProjectResponse = { appProject: "_appProject" };
function resolveWixVeloBackendV1AppProjectLifecycleUrl(opts) {
  var domainToMappings = {
    "manage._base_domain_": [
      {
        srcPath: "/_api/wix-code-app-projects",
        destPath: ""
      }
    ],
    "www._base_domain_": [
      {
        srcPath: "/_api/wix-code-app-projects",
        destPath: ""
      }
    ],
    "vibe._base_domain_": [
      {
        srcPath: "/_api/wix-code-app-projects",
        destPath: ""
      }
    ]
  };
  return resolveUrl(Object.assign(opts, { domainToMappings }));
}
function createAppProject(payload) {
  var _a = serializer(_createAppProjectRequest, { _appProject, _customDomain }), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_createAppProjectResponse, {
    _appProject,
    _customDomain
  }).fromJSON;
  function __createAppProject(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v1.app_project",
      method: "POST",
      methodFqn: "wix.velo.backend.v1.AppProjectLifecycle.CreateAppProject",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveWixVeloBackendV1AppProjectLifecycleUrl({
        protoPath: "/v1/app-projects",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __createAppProject.fromReq = fromReq;
  __createAppProject.__isAmbassador = true;
  return __createAppProject;
}
function getAppProject(payload) {
  var _a = serializer(_getAppProjectRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_getAppProjectResponse, {
    _appProject,
    _customDomain
  }).fromJSON;
  function __getAppProject(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v1.app_project",
      method: "GET",
      methodFqn: "wix.velo.backend.v1.AppProjectLifecycle.GetAppProject",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveWixVeloBackendV1AppProjectLifecycleUrl({
        protoPath: "/v1/app-projects/{appProjectId}",
        data: serializedData,
        host
      }),
      params: toURLSearchParams(serializedData),
      transformResponse: fromRes
    };
    return metadata;
  }
  __getAppProject.fromReq = fromReq;
  __getAppProject.__isAmbassador = true;
  return __getAppProject;
}

// ../../node_modules/@wix/ambassador-velo-backend-v2-app-environment-variable/es/build/http.impl.js
init_esm_shims();
var _appEnvironmentVariable = {
  createdDate: "google.protobuf.Timestamp",
  updatedDate: "google.protobuf.Timestamp"
};
var _bulkAppEnvironmentVariableResult = { item: "_appEnvironmentVariable" };
var _bulkUpsertAppEnvironmentVariablesRequest = {};
var _bulkUpsertAppEnvironmentVariablesResponse = {
  results: "_bulkAppEnvironmentVariableResult",
  appEnvironmentVariables: "_appEnvironmentVariable"
};
var _deleteAppEnvironmentVariableByEnvironmentAndKeyRequest = {};
var _deleteAppEnvironmentVariableByEnvironmentAndKeyResponse = {};
var _getAppEnvironmentVariablesByEnvironmentRequest = {};
var _getAppEnvironmentVariablesByEnvironmentResponse = {
  appEnvironmentVariables: "_appEnvironmentVariable"
};
function resolveWixVeloBackendV2AppEnvironmentVariableServiceUrl(opts) {
  var domainToMappings = {
    "manage._base_domain_": [
      {
        srcPath: "/_api/wix-code-app-environments",
        destPath: ""
      }
    ]
  };
  return resolveUrl(Object.assign(opts, { domainToMappings }));
}
function bulkUpsertAppEnvironmentVariables(payload) {
  var _a = serializer(_bulkUpsertAppEnvironmentVariablesRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_bulkUpsertAppEnvironmentVariablesResponse, { _appEnvironmentVariable, _bulkAppEnvironmentVariableResult }).fromJSON;
  function __bulkUpsertAppEnvironmentVariables(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v2.app_environment_variable",
      method: "POST",
      methodFqn: "wix.velo.backend.v2.AppEnvironmentVariableService.BulkUpsertAppEnvironmentVariables",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveWixVeloBackendV2AppEnvironmentVariableServiceUrl({
        protoPath: "/v2/bulk/app-projects/{appProjectId}/app-environment-variables/upsert",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __bulkUpsertAppEnvironmentVariables.fromReq = fromReq;
  __bulkUpsertAppEnvironmentVariables.__isAmbassador = true;
  return __bulkUpsertAppEnvironmentVariables;
}
function getAppEnvironmentVariablesByEnvironment(payload) {
  var _a = serializer(_getAppEnvironmentVariablesByEnvironmentRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_getAppEnvironmentVariablesByEnvironmentResponse, { _appEnvironmentVariable }).fromJSON;
  function __getAppEnvironmentVariablesByEnvironment(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v2.app_environment_variable",
      method: "GET",
      methodFqn: "wix.velo.backend.v2.AppEnvironmentVariableService.GetAppEnvironmentVariablesByEnvironment",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveWixVeloBackendV2AppEnvironmentVariableServiceUrl({
        protoPath: "/v2/app-projects/{appProjectId}/app-environment-variables/environment/{environment}",
        data: serializedData,
        host
      }),
      params: toURLSearchParams(serializedData),
      transformResponse: fromRes
    };
    return metadata;
  }
  __getAppEnvironmentVariablesByEnvironment.fromReq = fromReq;
  __getAppEnvironmentVariablesByEnvironment.__isAmbassador = true;
  return __getAppEnvironmentVariablesByEnvironment;
}
function deleteAppEnvironmentVariableByEnvironmentAndKey(payload) {
  var _a = serializer(_deleteAppEnvironmentVariableByEnvironmentAndKeyRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_deleteAppEnvironmentVariableByEnvironmentAndKeyResponse, {}).fromJSON;
  function __deleteAppEnvironmentVariableByEnvironmentAndKey(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v2.app_environment_variable",
      method: "DELETE",
      methodFqn: "wix.velo.backend.v2.AppEnvironmentVariableService.DeleteAppEnvironmentVariableByEnvironmentAndKey",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveWixVeloBackendV2AppEnvironmentVariableServiceUrl({
        protoPath: "/v2/app-projects/{appProjectId}/app-environment-variables/environment/{environment}/key/{key}",
        data: serializedData,
        host
      }),
      params: toURLSearchParams(serializedData),
      transformResponse: fromRes
    };
    return metadata;
  }
  __deleteAppEnvironmentVariableByEnvironmentAndKey.fromReq = fromReq;
  __deleteAppEnvironmentVariableByEnvironmentAndKey.__isAmbassador = true;
  return __deleteAppEnvironmentVariableByEnvironmentAndKey;
}

// ../../node_modules/@wix/ambassador-velo-backend-v2-app-environment-variable/es/build/types.impl.js
init_esm_shims();
var WebhookIdentityType;
(function(WebhookIdentityType3) {
  WebhookIdentityType3["UNKNOWN"] = "UNKNOWN";
  WebhookIdentityType3["ANONYMOUS_VISITOR"] = "ANONYMOUS_VISITOR";
  WebhookIdentityType3["MEMBER"] = "MEMBER";
  WebhookIdentityType3["WIX_USER"] = "WIX_USER";
  WebhookIdentityType3["APP"] = "APP";
})(WebhookIdentityType || (WebhookIdentityType = {}));
var SortOrder;
(function(SortOrder3) {
  SortOrder3["ASC"] = "ASC";
  SortOrder3["DESC"] = "DESC";
})(SortOrder || (SortOrder = {}));
var Mutability;
(function(Mutability2) {
  Mutability2["UNKNOWN_MUTABILITY"] = "UNKNOWN_MUTABILITY";
  Mutability2["STATIC"] = "STATIC";
  Mutability2["DYNAMIC"] = "DYNAMIC";
})(Mutability || (Mutability = {}));
var Sensitivity;
(function(Sensitivity2) {
  Sensitivity2["UNKNOWN_SENSITIVITY"] = "UNKNOWN_SENSITIVITY";
  Sensitivity2["PUBLIC"] = "PUBLIC";
  Sensitivity2["SECRET"] = "SECRET";
})(Sensitivity || (Sensitivity = {}));

// ../backend-as-a-service-client/src/schemas.ts
init_esm_shims();

// ../../node_modules/@wix/ambassador-velo-backend-v1-app-deployment/es/build/types.impl.js
init_esm_shims();
var CloudProvider;
(function(CloudProvider2) {
  CloudProvider2["UNKNOWN_CLOUD_PROVIDER"] = "UNKNOWN_CLOUD_PROVIDER";
  CloudProvider2["CLOUD_FLARE"] = "CLOUD_FLARE";
  CloudProvider2["KUBERNETES"] = "KUBERNETES";
})(CloudProvider || (CloudProvider = {}));
var DeploymentState;
(function(DeploymentState2) {
  DeploymentState2["UNKNOWN_DEPLOYMENT_STATE"] = "UNKNOWN_DEPLOYMENT_STATE";
  DeploymentState2["STATICS_UPLOAD_PENDING"] = "STATICS_UPLOAD_PENDING";
  DeploymentState2["DEPLOY_SUCCESS"] = "DEPLOY_SUCCESS";
  DeploymentState2["DEPLOY_FAILED"] = "DEPLOY_FAILED";
})(DeploymentState || (DeploymentState = {}));
var SortOrder2;
(function(SortOrder3) {
  SortOrder3["ASC"] = "ASC";
  SortOrder3["DESC"] = "DESC";
})(SortOrder2 || (SortOrder2 = {}));
var WebhookIdentityType2;
(function(WebhookIdentityType3) {
  WebhookIdentityType3["UNKNOWN"] = "UNKNOWN";
  WebhookIdentityType3["ANONYMOUS_VISITOR"] = "ANONYMOUS_VISITOR";
  WebhookIdentityType3["MEMBER"] = "MEMBER";
  WebhookIdentityType3["WIX_USER"] = "WIX_USER";
  WebhookIdentityType3["APP"] = "APP";
})(WebhookIdentityType2 || (WebhookIdentityType2 = {}));

// ../backend-as-a-service-client/src/schemas.ts
var staticFileMetadata = external_exports.object({
  path: external_exports.string(),
  hash: external_exports.string(),
  size: external_exports.number().optional(),
  contentType: external_exports.string()
});
var StaticFileUploadUrlSchema = external_exports.object({
  uploadUrl: external_exports.string().url(),
  staticFileMetadata
});
var AppDeploymentSchema = external_exports.object({
  id: external_exports.string().uuid(),
  deploymentBaseUrl: external_exports.string(),
  cloudProviderOverride: external_exports.nativeEnum(CloudProvider)
}).passthrough();
var CompleteAppDeploymentSchema = external_exports.object({
  appDeployment: AppDeploymentSchema
});
var AppProjectSchema = external_exports.object({
  appProject: external_exports.object({
    id: external_exports.string().uuid(),
    baseUrl: external_exports.string().url(),
    customDomain: external_exports.object({
      domain: external_exports.string()
    }).optional()
  })
});
var CreateAppProjectSchema = external_exports.object({
  appProject: external_exports.object({
    id: external_exports.string().uuid(),
    baseUrl: external_exports.string().url(),
    customDomain: external_exports.object({
      domain: external_exports.string()
    }).optional()
  })
});
var CreateAppDeploymentSchema = external_exports.object({
  staticFilesUploadUrls: external_exports.array(StaticFileUploadUrlSchema).optional(),
  uploadAuthToken: external_exports.string().optional(),
  appDeployment: AppDeploymentSchema.optional(),
  uploadBuckets: external_exports.array(
    external_exports.object({
      hashes: external_exports.array(external_exports.string()).optional()
    })
  ).optional()
});
var StaticFileUploadSchema = external_exports.object({
  result: external_exports.object({
    // The `jwt` field is optional because it is only returned in the last file upload.
    jwt: external_exports.string().optional()
  }).optional()
}).passthrough();
var AppEnvironmentVariableSchema = external_exports.object({
  key: external_exports.string(),
  value: external_exports.string()
});
var AppEnvironmentVariablesSchema = external_exports.array(AppEnvironmentVariableSchema).optional().transform((variables) => {
  return (variables ?? []).reduce((acc, curr) => {
    acc[curr.key] = curr.value;
    return acc;
  }, {});
});
var GetAppEnvironmentVariablesSchema = external_exports.object({
  appEnvironmentVariables: AppEnvironmentVariablesSchema
});
var UpsertAppEnvironmentVariablesSchema = external_exports.object({
  appEnvironmentVariables: AppEnvironmentVariablesSchema,
  results: external_exports.array(external_exports.unknown()).optional(),
  bulkActionMetadata: external_exports.object({
    totalSuccesses: external_exports.number().optional(),
    totalFailures: external_exports.number().optional(),
    undetailedFailures: external_exports.number().optional()
  }).optional()
});

// ../backend-as-a-service-client/src/backend-as-a-service-client.ts
var { minRetryTimeout } = getTestOverrides();
var APP_PROJECT_TYPE_ID = "79144b61-68b9-4b0b-bfa7-e3adfa610101";
var HEADLESS_PROJECT_TYPE_ID = "eb363dea-85a0-4159-9b05-949542be5079";
var BackendAsAServiceClient = class {
  constructor(httpClient) {
    this.httpClient = httpClient;
    this.retryOptions = {
      retries: 3,
      minTimeout: minRetryTimeout,
      maxTimeout: 3 * 1e3
    };
  }
  retryOptions;
  getAppProject = async (appId) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(getAppProject({ appProjectId: appId })),
        this.retryOptions
      );
      return AppProjectSchema.parse(data).appProject;
    } catch (e) {
      if (isHttpError(e) && e.response?.status === 404) {
        return;
      }
      throw new CliError({
        code: CliErrorCode.FailedToGetAppProject(),
        cause: e
      });
    }
  };
  createAppProject = async ({
    cloudProvider,
    projectType,
    ...appProjectOptions
  }) => {
    try {
      const { data } = await this.httpClient.request(
        createAppProject({
          appProject: {
            ...appProjectOptions,
            appProjectTypeId: projectType === "HEADLESS" ? HEADLESS_PROJECT_TYPE_ID : APP_PROJECT_TYPE_ID,
            cloudProviderOverride: cloudProvider
          }
        })
      );
      return CreateAppProjectSchema.parse(data).appProject;
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedCreatingAppProject(),
        cause: e
      });
    }
  };
  createAppDeployment = async (appId, files, staticFilesMetadata, generateAppDeploymentGroupId) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(
          createAppDeployment({
            appDeployment: {
              appProjectId: appId,
              files,
              staticFilesMetadata,
              appDeploymentGroupId: generateAppDeploymentGroupId ? randomUUID() : void 0
            }
          })
        ),
        this.retryOptions
      );
      return CreateAppDeploymentSchema.parse(data);
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedCreatingAppDeployment(),
        cause: e
      });
    }
  };
  completeAppDeployment = async (appDeployment, staticsCompletionToken) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(
          completeAppDeployment({
            appDeployment,
            staticsCompletionToken
          })
        ),
        this.retryOptions
      );
      return CompleteAppDeploymentSchema.parse(data).appDeployment;
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedFinalizingAppDeployment(),
        cause: e
      });
    }
  };
  postForm = async (endpointUrl, token, formData) => {
    try {
      const responseJson = await pRetry(
        async () => {
          const response = await fetch(endpointUrl, {
            method: "POST",
            headers: {
              Authorization: `Bearer ${token}`
            },
            body: formData
          });
          if (!response.ok) {
            const error = await createHttpErrorFromFetch(response);
            throw error;
          }
          return response.json();
        },
        { retries: 3 }
      );
      return StaticFileUploadSchema.parse(responseJson);
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToUploadStaticFiles(),
        cause: e,
        info: { endpointUrl }
      });
    }
  };
  putBinaryFile = async (endpointUrl, fileContent, contentType) => {
    try {
      await pRetry(
        async () => {
          const response = await fetch(endpointUrl, {
            method: "PUT",
            headers: {
              "Content-Type": contentType
            },
            body: fileContent
          });
          if (!response.ok) {
            const error = await createHttpErrorFromFetch(response);
            throw error;
          }
        },
        { retries: 3 }
      );
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToUploadStaticFiles(),
        cause: e,
        info: { endpointUrl }
      });
    }
  };
  // Env management
  getAppEnvironmentVariables = async (appId, environment) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(
          getAppEnvironmentVariablesByEnvironment({
            appProjectId: appId,
            environment
          })
        ),
        this.retryOptions
      );
      const { appEnvironmentVariables } = GetAppEnvironmentVariablesSchema.parse(data);
      return appEnvironmentVariables;
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToGetAppEnvironmentVariablesByEnvironment(),
        cause: e
      });
    }
  };
  upsertAppEnvironmentVariables = async (appId, environment, variables) => {
    let result;
    try {
      const { data } = await this.httpClient.request(
        bulkUpsertAppEnvironmentVariables({
          appProjectId: appId,
          environment,
          variables,
          mutability: Mutability.STATIC,
          returnEntity: true,
          returnAllEnvironment: true
        })
      );
      result = UpsertAppEnvironmentVariablesSchema.parse(data);
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToBulkUpsertAppEnvironmentVariables(),
        cause: e
      });
    }
    const { bulkActionMetadata, appEnvironmentVariables } = result;
    if (bulkActionMetadata?.totalFailures || bulkActionMetadata?.undetailedFailures) {
      throw new CliError({
        code: CliErrorCode.FailedToBulkUpsertAppEnvironmentVariables(),
        cause: void 0,
        info: { ...result }
      });
    }
    return appEnvironmentVariables;
  };
  deleteAppEnvironmentVariable = async (appId, environment, variable) => {
    try {
      await this.httpClient.request(
        deleteAppEnvironmentVariableByEnvironmentAndKey({
          appProjectId: appId,
          environment,
          key: variable
        })
      );
    } catch (e) {
      if (isHttpError(e) && isHttpApplicationError(e)) {
        const applicationError = e.response?.data.details.applicationError;
        if (applicationError?.code === "APP_ENVIRONMENT_VARIABLE_NOT_FOUND") {
          return;
        }
      }
      throw new CliError({
        code: CliErrorCode.FailedToDeleteAppEnvironmentVariableByEnvironmentAndKey(),
        cause: e
      });
    }
  };
};

// ../backend-as-a-service-client/src/useBackendAsAServiceClient.ts
function useBackendAsAServiceClient() {
  const httpClient = useHttpClient({ type: "backoffice" });
  const client = (0, import_react.useMemo)(
    () => new BackendAsAServiceClient(httpClient),
    [httpClient]
  );
  return usePanoramaMethodLogger(client);
}

// ../backend-as-a-service-client/src/index.ts
init_esm_shims();

export {
  CloudProvider,
  useBackendAsAServiceClient
};
//# sourceMappingURL=chunk-JQOAY3IH.js.map