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

CLI tool for building Wix sites and applications

import { createRequire as _createRequire } from 'node:module';
const require = _createRequire(import.meta.url);
import {
  require_lodash
} from "./chunk-J5YVHTPQ.js";
import {
  useHttpClient
} from "./chunk-NPIBHDAX.js";
import {
  pRetry,
  resolveUrl,
  serializer,
  toURLSearchParams
} from "./chunk-PLPLA7N3.js";
import {
  require_react
} from "./chunk-5A5B2WR4.js";
import {
  getTestOverrides
} from "./chunk-WYHHEOWO.js";
import {
  z
} from "./chunk-ZXYGJZOO.js";
import {
  CliError,
  CliErrorCode
} from "./chunk-D5VYILRO.js";
import {
  __toESM,
  init_esm_shims
} from "./chunk-4EFJZ3GQ.js";

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

// ../backend-as-a-service-client/src/backend-as-a-service-client.ts
init_esm_shims();
var import_lodash = __toESM(require_lodash(), 1);

// ../../node_modules/@wix/ambassador-velo-backend-v1-app-deployment/build/es/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",
      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",
      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"
};
var _createAppProjectRequest = { appProject: "_appProject" };
var _createAppProjectResponse = { appProject: "_appProject" };
function resolveWixVeloBackendV1AppProjectLifecycleUrl(opts) {
  var domainToMappings = {
    "manage._base_domain_": [
      {
        srcPath: "/_api/wix-code-app-projects",
        destPath: ""
      }
    ]
  };
  return resolveUrl(Object.assign(opts, { domainToMappings }));
}
function createAppProject(payload) {
  var _a = serializer(_createAppProjectRequest, { _appProject }), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_createAppProjectResponse, {
    _appProject
  }).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",
      url: resolveWixVeloBackendV1AppProjectLifecycleUrl({
        protoPath: "/v1/app-projects",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __createAppProject.fromReq = fromReq;
  __createAppProject.__isAmbassador = true;
  return __createAppProject;
}

// ../../node_modules/@wix/ambassador-velo-backend-v1-app-environment/build/es/http.impl.js
init_esm_shims();
var _appEnvironment = {
  createdDate: "google.protobuf.Timestamp",
  updatedDate: "google.protobuf.Timestamp"
};
var _getAppEnvironmentByNameRequest = {};
var _getAppEnvironmentByNameResponse = { appEnvironment: "_appEnvironment" };
var _removeAppEnvironmentVariablesRequest = {};
var _removeAppEnvironmentVariablesResponse = {
  appEnvironment: "_appEnvironment"
};
var _upsertAppEnvironmentRequest = {
  fieldMask: "google.protobuf.FieldMask",
  appEnvironment: "_appEnvironment"
};
var _upsertAppEnvironmentResponse = { appEnvironment: "_appEnvironment" };
function resolveWixVeloBackendV1AppEnvironmentManagementUrl(opts) {
  var domainToMappings = {
    "manage._base_domain_": [
      {
        srcPath: "/_api/wix-code-app-environments",
        destPath: ""
      }
    ]
  };
  return resolveUrl(Object.assign(opts, { domainToMappings }));
}
function upsertAppEnvironment(payload) {
  var _a = serializer(_upsertAppEnvironmentRequest, { _appEnvironment }), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_upsertAppEnvironmentResponse, {
    _appEnvironment
  }).fromJSON;
  function __upsertAppEnvironment(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v1.app_environment",
      method: "POST",
      methodFqn: "wix.velo.backend.v1.AppEnvironmentManagement.UpsertAppEnvironment",
      url: resolveWixVeloBackendV1AppEnvironmentManagementUrl({
        protoPath: "/v1/app-projects/{appEnvironment.appProjectId}/app-environments/upsert/name/{appEnvironment.name}",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __upsertAppEnvironment.fromReq = fromReq;
  __upsertAppEnvironment.__isAmbassador = true;
  return __upsertAppEnvironment;
}
function getAppEnvironmentByName(payload) {
  var _a = serializer(_getAppEnvironmentByNameRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_getAppEnvironmentByNameResponse, {
    _appEnvironment
  }).fromJSON;
  function __getAppEnvironmentByName(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v1.app_environment",
      method: "GET",
      methodFqn: "wix.velo.backend.v1.AppEnvironmentManagement.GetAppEnvironmentByName",
      url: resolveWixVeloBackendV1AppEnvironmentManagementUrl({
        protoPath: "/v1/app-projects/{appProjectId}/app-environments/name/{appEnvironmentName}",
        data: serializedData,
        host
      }),
      params: toURLSearchParams(serializedData),
      transformResponse: fromRes
    };
    return metadata;
  }
  __getAppEnvironmentByName.fromReq = fromReq;
  __getAppEnvironmentByName.__isAmbassador = true;
  return __getAppEnvironmentByName;
}
function removeAppEnvironmentVariables(payload) {
  var _a = serializer(_removeAppEnvironmentVariablesRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_removeAppEnvironmentVariablesResponse, { _appEnvironment }).fromJSON;
  function __removeAppEnvironmentVariables(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.velo.backend.v1.app_environment",
      method: "POST",
      methodFqn: "wix.velo.backend.v1.AppEnvironmentManagement.RemoveAppEnvironmentVariables",
      url: resolveWixVeloBackendV1AppEnvironmentManagementUrl({
        protoPath: "/v1/app-projects/{appProjectId}/app-environments/{appEnvironmentId}/remove",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __removeAppEnvironmentVariables.fromReq = fromReq;
  __removeAppEnvironmentVariables.__isAmbassador = true;
  return __removeAppEnvironmentVariables;
}

// ../backend-as-a-service-client/src/schemas.ts
init_esm_shims();
var staticFileMetadata = z.object({
  path: z.string(),
  hash: z.string(),
  size: z.number().optional(),
  contentType: z.string().optional().nullable()
});
var StaticFileUploadUrlSchema = z.object({
  uploadUrl: z.string().url(),
  staticFileMetadata
});
var AppDeploymentSchema = z.object({
  id: z.string().uuid(),
  deploymentBaseUrl: z.string()
}).passthrough();
var CompleteAppDeploymentSchema = z.object({
  appDeployment: AppDeploymentSchema
});
var AppEnvironmentSchema = z.object({
  appEnvironment: z.object({
    id: z.string(),
    variables: z.record(z.string()),
    secrets: z.record(z.string())
  }).passthrough()
});
var CreateAppProjectSchema = z.object({
  appProject: z.object({
    id: z.string().uuid(),
    baseUrl: z.string().url()
  })
});
var CreateAppDeploymentSchema = z.object({
  staticFilesUploadUrls: z.array(StaticFileUploadUrlSchema).optional(),
  uploadAuthToken: z.string(),
  appDeployment: AppDeploymentSchema.optional()
});
var StaticFileUploadSchema = z.object({
  result: z.object({
    // The `jwt` field is optional because it is only returned in the last file upload.
    jwt: z.string().optional()
  }).optional()
}).passthrough();

// ../backend-as-a-service-client/src/backend-as-a-service-client.ts
var { minRetryTimeout } = getTestOverrides();
var APP_PROJECT_TYPE_ID = "35252494-7615-4117-9c4c-53ae7d3be95f";
var BackendAsAServiceClient = class {
  constructor(httpClient) {
    this.httpClient = httpClient;
    this.retryOptions = {
      retries: 3,
      minTimeout: minRetryTimeout,
      maxTimeout: 3 * 1e3
    };
  }
  retryOptions;
  createAppProject = async (appId, projectName) => {
    try {
      const { data } = await this.httpClient.request(
        createAppProject({
          appProject: {
            id: appId,
            displayName: projectName,
            slug: (0, import_lodash.kebabCase)(projectName),
            appProjectTypeId: APP_PROJECT_TYPE_ID
          }
        })
      );
      return CreateAppProjectSchema.parse(data);
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedCreatingAppProject(),
        cause: e
      });
    }
  };
  createAppDeployment = async (appId, staticFilesMetadata) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(
          createAppDeployment({
            appDeployment: {
              appProjectId: appId,
              staticFilesMetadata
            }
          })
        ),
        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) {
            throw new Error(response.statusText);
          }
          return response.json();
        },
        { retries: 3 }
      );
      return StaticFileUploadSchema.parse(responseJson);
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToUploadStaticFiles(),
        cause: e
      });
    }
  };
  // Env management
  getAppEnvironmentByName = async (appId, environment) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(
          getAppEnvironmentByName({
            appProjectId: appId,
            appEnvironmentName: environment
          })
        ),
        this.retryOptions
      );
      return AppEnvironmentSchema.parse(data).appEnvironment;
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToPullEnvironment(),
        cause: e
      });
    }
  };
  upsertAppEnvironment = async (appId, environment, variables) => {
    try {
      const { data } = await this.httpClient.request(
        upsertAppEnvironment({
          appEnvironment: {
            appProjectId: appId,
            name: environment,
            variables
          }
        })
      );
      return AppEnvironmentSchema.parse(data).appEnvironment;
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToSetEnvironmentVariable(),
        cause: e
      });
    }
  };
  removeAppEnvironmentVariable = async (appId, environment, variable) => {
    try {
      const appEnvironment = await this.getAppEnvironmentByName(
        appId,
        environment
      );
      const { data } = await pRetry(
        () => this.httpClient.request(
          removeAppEnvironmentVariables({
            appEnvironmentId: appEnvironment.id,
            appProjectId: appId,
            variables: [variable]
          })
        ),
        this.retryOptions
      );
      return AppEnvironmentSchema.parse(data).appEnvironment;
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToRemoveEnvironmentVariable(),
        cause: e
      });
    }
  };
};

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

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

export {
  useBackendAsAServiceClient
};
//# sourceMappingURL=chunk-FY52VUHM.js.map