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

CLI tool for building Wix sites and applications

import { createRequire as _createRequire } from 'node:module';
const require = _createRequire(import.meta.url);
import {
  getDeployment,
  getDeploymentPipelineDescription,
  publishDeployment
} from "./chunk-ZYYEEWNQ.js";
import {
  DeploymentPipelinesStatus,
  TaskStatus
} from "./chunk-CSMKGG4V.js";
import {
  useHttpClient
} from "./chunk-NPIBHDAX.js";
import {
  pRetry,
  pWaitFor
} 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,
  require_lib
} from "./chunk-D5VYILRO.js";
import {
  __toESM,
  init_esm_shims
} from "./chunk-4EFJZ3GQ.js";

// ../document-management-client/src/document-management-client.ts
init_esm_shims();
var import_variant = __toESM(require_lib(), 1);

// ../document-management-client/src/schemas.ts
init_esm_shims();
var getDeploymentSchema = z.object({
  deployment: z.object({
    deploymentPipelinesStatus: z.enum([
      DeploymentPipelinesStatus.IN_PROGRESS,
      DeploymentPipelinesStatus.SUCCESS,
      DeploymentPipelinesStatus.ERROR
    ])
  })
});
var taskDescriptionSchema = z.object({
  taskName: z.string(),
  status: z.string().transform(
    (value) => value === TaskStatus.SUCCESS ? TaskStatus.SUCCESS : TaskStatus.ERROR
  ),
  description: z.string().nullish().transform((value, ctx) => {
    try {
      return value ? JSON.parse(value) : {};
    } catch {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: "Invalid JSON"
      });
    }
    return value;
  }).pipe(z.record(z.string(), z.string()))
});
var getDeploymentPipelineDescriptionSchema = z.object({
  pipelinesDescription: z.array(
    z.object({
      deploymentPipelineId: z.string(),
      tasksDescriptions: z.array(taskDescriptionSchema)
    })
  )
});

// ../document-management-client/src/document-management-client.ts
var { minRetryTimeout, pollInterval } = getTestOverrides();
var VELO_PIPELINE_ID = "5c696513-2584-4f19-ae0f-a559dd649482";
var DeploymentStatus = (0, import_variant.variant)({
  Success: {},
  Error: (0, import_variant.fields)()
});
var DocumentManagementClient = class {
  constructor(httpClient) {
    this.httpClient = httpClient;
    this.retryOptions = {
      retries: 1,
      minTimeout: minRetryTimeout,
      maxTimeout: 3 * 1e3
    };
  }
  retryOptions;
  getDeploymentDetails = async (deploymentId) => {
    const deploymentStatus = await this.getDeploymentStatus(deploymentId);
    if (deploymentStatus === DeploymentPipelinesStatus.ERROR) {
      const tasksDescriptions = await this.getDeploymentTasksDescriptions(deploymentId);
      return DeploymentStatus.Error({
        deploymentError: new CliError({
          code: CliErrorCode.DeploymentPipelineFailed({ tasksDescriptions }),
          cause: null
        })
      });
    }
    return DeploymentStatus.Success();
  };
  getDeploymentStatus = async (deploymentId) => {
    try {
      return await pWaitFor(
        async () => {
          const { data } = await pRetry(
            () => this.httpClient.request(getDeployment({ deploymentId })),
            this.retryOptions
          );
          const result = getDeploymentSchema.safeParse(data);
          if (!result.success) {
            throw new CliError({
              code: CliErrorCode.InvalidGetDeploymentResponse(),
              cause: result.error,
              info: { data }
            });
          }
          const { deploymentPipelinesStatus: status } = result.data.deployment;
          if (status === DeploymentPipelinesStatus.IN_PROGRESS) {
            return false;
          }
          return pWaitFor.resolveWith(status);
        },
        {
          // Poll each 2 seconds
          interval: pollInterval ?? 2 * 1e3,
          // Fail if 2 minutes passed
          timeout: 2 * 60 * 1e3
        }
      );
    } catch (error) {
      throw new CliError({
        code: CliErrorCode.FailedToGetDeploymentStatus(),
        cause: error
      });
    }
  };
  getDeploymentTasksDescriptions = async (deploymentId) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(
          getDeploymentPipelineDescription({
            deploymentId,
            deploymentPipelinesIds: [VELO_PIPELINE_ID]
          })
        ),
        this.retryOptions
      );
      const result = getDeploymentPipelineDescriptionSchema.safeParse(data);
      if (!result.success) {
        throw new CliError({
          code: CliErrorCode.InvalidGetDeploymentPipelineDescriptionResponse(),
          cause: result.error,
          info: { data }
        });
      }
      const veloPipeline = result.data.pipelinesDescription.find(
        (item) => item.deploymentPipelineId === VELO_PIPELINE_ID
      );
      return veloPipeline?.tasksDescriptions ?? [];
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToGetDeploymentPipelineDescription(),
        cause: e
      });
    }
  };
  publishDeployment = async (deploymentId) => {
    try {
      await this.httpClient.request(
        publishDeployment({ deploymentId, skipPipelineCheck: true })
      );
    } catch (error) {
      throw new CliError({
        code: CliErrorCode.FailedToPublishDeployment(),
        cause: error
      });
    }
  };
};

// ../document-management-client/src/useDocumentManagementClient.ts
init_esm_shims();
var import_react = __toESM(require_react(), 1);
function useDocumentManagementClient() {
  const httpClient = useHttpClient({ type: "editor" });
  return (0, import_react.useMemo)(() => new DocumentManagementClient(httpClient), [httpClient]);
}

// ../document-management-client/src/index.ts
init_esm_shims();

export {
  DeploymentStatus,
  useDocumentManagementClient
};
//# sourceMappingURL=chunk-HTWXHHYU.js.map