@shopify/oxygen-cli 1.4.0 → 1.6.0

package/dist/deploy/deployment-initiate.js

@@ -1,10 +1,11 @@
 import { graphqlRequest } from '@shopify/cli-kit/node/api/graphql';
 import { AbortError } from '@shopify/cli-kit/node/error';
 import { outputCompleted } from '@shopify/cli-kit/node/output';
-import { Header, stderrLogger, errorHandler } from '../utils/utils.js';
+import { Header, errorHandler } from '../utils/utils.js';
 import { DeploymentInitiateQuery } from './graphql/deployment-initiate.js';
 
-async function deploymentInitiate(config, input) {
+async function deploymentInitiate(options) {
+  const { config, input, logger } = options;
   const variables = {
     buildId: input.buildId,
     environment: input.environment,
@@ -30,7 +31,7 @@ async function deploymentInitiate(config, input) {
     }
     outputCompleted(
       `Deployment initiated, ${response.deploymentInitiate.deploymentTargets.length} files to upload.`,
-      stderrLogger
+      logger
     );
     return response.deploymentInitiate;
   } catch (error) {

package/dist/deploy/deployment-initiate.test.js

@@ -3,7 +3,7 @@ import { graphqlRequest } from '@shopify/cli-kit/node/api/graphql';
 import { outputCompleted } from '@shopify/cli-kit/node/output';
 import { vi, describe, test, expect } from 'vitest';
 import { createTestConfig } from '../utils/test-helper.js';
-import { Header, stderrLogger } from '../utils/utils.js';
+import { stderrLogger, Header } from '../utils/utils.js';
 import { deploymentInitiate } from './deployment-initiate.js';
 
 vi.mock("@shopify/cli-kit/node/api/graphql");
@@ -38,9 +38,13 @@ const testResponse = {
 describe("DeploymentInitiate", () => {
   test("should initiate a deployment with a buildId", async () => {
     vi.mocked(graphqlRequest).mockResolvedValueOnce(testResponse);
-    const initiateResponse = await deploymentInitiate(testConfig, {
-      buildId: "build-1",
-      manifest: testManifest
+    const initiateResponse = await deploymentInitiate({
+      config: testConfig,
+      input: {
+        buildId: "build-1",
+        manifest: testManifest
+      },
+      logger: stderrLogger
     });
     expect(initiateResponse).toEqual(testResponse.deploymentInitiate);
     expect(graphqlRequest).toHaveBeenCalledWith({
@@ -65,10 +69,14 @@ describe("DeploymentInitiate", () => {
   });
   test("should initiate a deployment with an environmentName", async () => {
     vi.mocked(graphqlRequest).mockResolvedValueOnce(testResponse);
-    const initiateResponse = await deploymentInitiate(testConfig, {
-      buildId: void 0,
-      environment: { tag: "preview" },
-      manifest: testManifest
+    const initiateResponse = await deploymentInitiate({
+      config: testConfig,
+      input: {
+        buildId: void 0,
+        environment: { tag: "preview" },
+        manifest: testManifest
+      },
+      logger: stderrLogger
     });
     expect(initiateResponse).toEqual(testResponse.deploymentInitiate);
     expect(graphqlRequest).toHaveBeenCalledWith({
@@ -108,7 +116,11 @@ describe("DeploymentInitiate", () => {
       manifest: testManifest
     };
     await expect(
-      deploymentInitiate(testConfig, deploymentInitData)
+      deploymentInitiate({
+        config: testConfig,
+        input: deploymentInitData,
+        logger: stderrLogger
+      })
     ).rejects.toThrow(
       new AbortError(
         `Failed to create deployment. ${response.deploymentInitiate.userErrors[0]?.message}`
@@ -127,7 +139,11 @@ describe("DeploymentInitiate", () => {
         manifest: testManifest
       };
       await expect(
-        deploymentInitiate(testConfig, deploymentInitData)
+        deploymentInitiate({
+          config: testConfig,
+          input: deploymentInitData,
+          logger: stderrLogger
+        })
       ).rejects.toThrow(
         new AbortError(
           "You are not authorized to perform this action. Please check your deployment token."

package/dist/deploy/get-upload-files.d.ts

@@ -1,5 +1,5 @@
-import { DeployConfig, DeploymentManifestFile } from './types.js';
+import { DeploymentConfig, DeploymentManifestFile } from './types.js';
 
-declare function getUploadFiles(config: DeployConfig): Promise<DeploymentManifestFile[]>;
+declare function getUploadFiles(config: DeploymentConfig): Promise<DeploymentManifestFile[]>;
 
 export { getUploadFiles };

package/dist/deploy/health-check.d.ts

@@ -0,0 +1,12 @@
+import { Logger } from '@shopify/cli-kit/node/output';
+import { DeploymentConfig, DeploymentHooks } from './types.js';
+
+interface HealthCheckOptions {
+    config: DeploymentConfig;
+    hooks?: DeploymentHooks;
+    logger: Logger;
+    url: string;
+}
+declare function healthCheck(options: HealthCheckOptions): Promise<void>;
+
+export { healthCheck };

package/dist/deploy/health-check.js

@@ -0,0 +1,44 @@
+import { fetch } from '@shopify/cli-kit/node/http';
+import { outputInfo } from '@shopify/cli-kit/node/output';
+import { HealthCheckError } from './types.js';
+
+async function healthCheck(options) {
+  const { config, url, logger, hooks } = options;
+  hooks?.onHealthCheckStart?.();
+  outputInfo("Performing health check on the deployment...", logger);
+  let attempts = 0;
+  let delay = 0;
+  const startTime = Date.now();
+  const handleInterval = async () => {
+    if (attempts < 10) {
+      delay = 500;
+    } else if (attempts % 5 === 0) {
+      delay += 5e3;
+    }
+    const elapsedTime = (Date.now() - startTime) / 1e3;
+    if (elapsedTime + delay / 1e3 > config.healthCheckMaxDuration) {
+      const error = new HealthCheckError("Unable to verify deployment health.");
+      hooks?.onHealthCheckError?.(error);
+      throw error;
+    }
+    attempts++;
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    await check();
+  };
+  const check = async () => {
+    try {
+      const response = await fetch(`${url}/.oxygen/deployment`);
+      if (response.status === 200) {
+        outputInfo("Deployment health check passed", logger);
+        hooks?.onHealthCheckComplete?.();
+        return Promise.resolve();
+      }
+      await handleInterval();
+    } catch {
+      await handleInterval();
+    }
+  };
+  await check();
+}
+
+export { healthCheck };

package/dist/deploy/health-check.test.d.ts

@@ -0,0 +1,2 @@
+
+export { }

package/dist/deploy/health-check.test.js

@@ -0,0 +1,92 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { fetch } from '@shopify/cli-kit/node/http';
+import { Response } from 'node-fetch';
+import { stderrLogger } from '../utils/utils.js';
+import { createTestConfig } from '../utils/test-helper.js';
+import { HealthCheckError } from './types.js';
+import { healthCheck } from './health-check.js';
+
+vi.mock("@shopify/cli-kit/node/http", async () => {
+  const actual = await vi.importActual("@shopify/cli-kit/node/http");
+  return {
+    ...actual,
+    fetch: vi.fn()
+  };
+});
+vi.mock("@shopify/cli-kit/node/output");
+const testConfig = createTestConfig("rootFolder");
+describe("healthCheck", () => {
+  let setTimeoutSpy;
+  const hooks = {
+    onHealthCheckError: vi.fn(),
+    onHealthCheckStart: vi.fn(),
+    onHealthCheckComplete: vi.fn()
+  };
+  const url = "http://example.com";
+  beforeEach(() => {
+    vi.mocked(fetch).mockReset();
+    setTimeoutSpy = vi.spyOn(global, "setTimeout").mockImplementation((cb, _delay) => {
+      cb();
+      return {};
+    });
+  });
+  it("resolves when URL is accessible", async () => {
+    const response = new Response();
+    vi.mocked(fetch).mockResolvedValueOnce(response);
+    await healthCheck({ config: testConfig, url, logger: stderrLogger, hooks });
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith(`${url}/.oxygen/deployment`);
+    expect(hooks.onHealthCheckStart).toBeCalled();
+    expect(hooks.onHealthCheckComplete).toBeCalled();
+  });
+  it("repeats request until URL is accessible with progressive timeout", async () => {
+    const responseFail = new Response(null, { status: 404 });
+    const responseSuccess = new Response(null, { status: 200 });
+    let attempts = 0;
+    vi.mocked(fetch).mockImplementation(() => {
+      if (attempts === 30) {
+        return Promise.resolve(responseSuccess);
+      }
+      attempts++;
+      return Promise.resolve(responseFail);
+    });
+    await new Promise((resolve, reject) => {
+      healthCheck({ config: testConfig, url, logger: stderrLogger, hooks }).then(() => {
+        expect(fetch).toHaveBeenCalledTimes(attempts + 1);
+        expect(fetch).toHaveBeenCalledWith(`${url}/.oxygen/deployment`);
+        expect(setTimeoutSpy).toHaveBeenCalledTimes(attempts);
+        expect(hooks.onHealthCheckStart).toBeCalled();
+        expect(hooks.onHealthCheckComplete).toBeCalled();
+        let expectedDuration = 500;
+        setTimeoutSpy.mock.calls.forEach(
+          (call, index) => {
+            if (index >= 10 && index % 5 === 0) {
+              expectedDuration += 5e3;
+            }
+            expect(call[1]).toBe(expectedDuration);
+          }
+        );
+        resolve();
+      }).catch((error) => {
+        reject(error);
+      });
+    });
+  });
+  it("throws an error after max duration", async () => {
+    vi.useFakeTimers();
+    const responseFail = new Response(null, { status: 404 });
+    vi.mocked(fetch).mockResolvedValue(responseFail);
+    const healthCheckPromise = healthCheck({
+      config: testConfig,
+      url,
+      logger: stderrLogger,
+      hooks
+    });
+    vi.setSystemTime(Date.now() + testConfig.healthCheckMaxDuration * 1e3);
+    await expect(healthCheckPromise).rejects.toThrow(HealthCheckError);
+    expect(fetch).toHaveBeenCalledOnce();
+    expect(hooks.onHealthCheckStart).toBeCalled();
+    expect(hooks.onHealthCheckError).toBeCalled();
+    vi.useRealTimers();
+  });
+});

package/dist/deploy/index.d.ts

@@ -1,5 +1,12 @@
-import { DeployConfig } from './types.js';
+import { Logger } from '@shopify/cli-kit/node/output';
+import { DeploymentConfig, DeploymentHooks } from './types.js';
+export { parseToken } from '../utils/utils.js';
 
-declare function createDeploy(config: DeployConfig): Promise<void>;
+interface CreateDeployOptions {
+    config: DeploymentConfig;
+    hooks?: DeploymentHooks;
+    logger?: Logger;
+}
+declare function createDeploy(options: CreateDeployOptions): Promise<string | undefined>;
 
-export { createDeploy };
+export { DeploymentConfig, DeploymentHooks, createDeploy };

package/dist/deploy/index.js

@@ -1,88 +1,116 @@
-import { outputSuccess, outputInfo, outputWarn, consoleError } from '@shopify/cli-kit/node/output';
-import { verifyConfig, stderrLogger } from '../utils/utils.js';
+import { outputSuccess, outputInfo, outputWarn } from '@shopify/cli-kit/node/output';
+import { stderrLogger, verifyConfig } from '../utils/utils.js';
+export { parseToken } from '../utils/utils.js';
 import { buildInitiate } from './build-initiate.js';
 import { buildCancel } from './build-cancel.js';
 import { getUploadFiles } from './get-upload-files.js';
 import { deploymentInitiate } from './deployment-initiate.js';
 import { deploymentComplete } from './deployment-complete.js';
+import { healthCheck } from './health-check.js';
 import { deploymentCancel, DeploymentCancelReason } from './deployment-cancel.js';
 import { uploadFiles } from './upload-files.js';
+import { HealthCheckError } from './types.js';
 import { buildProject } from './build-project.js';
 import { getMetadata, createLabels, getEnvironmentInput } from './metadata.js';
 
-async function createDeploy(config) {
+async function createDeploy(options) {
+  const { config, hooks } = options;
+  const logger = options.logger ?? stderrLogger;
   const build = {};
   let buildCompleted;
   let deployment;
   try {
-    const metadata = await getMetadata(config);
+    const metadata = await getMetadata(config, logger);
     const labels = createLabels(metadata);
     const environment = getEnvironmentInput(config, metadata);
     if (!config.workerOnly && !config.skipBuild) {
-      const buildInitiateResponse = await buildInitiate(
+      const buildInitiateResponse = await buildInitiate({
         config,
         environment,
-        labels
-      );
+        labels,
+        logger
+      });
       build.id = buildInitiateResponse.build.id;
       build.assetPath = buildInitiateResponse.build.assetPath;
     }
     if (!config.skipBuild) {
-      await buildProject(config, build.assetPath);
+      await buildProject({
+        config,
+        assetPath: build.assetPath,
+        hooks
+      });
       verifyConfig({ config, performedBuild: true });
     }
     buildCompleted = true;
     const manifest = await getUploadFiles(config);
     const deploymentInitiateInput = build.id ? { buildId: build.id, manifest } : { environment, manifest, labels };
-    deployment = await deploymentInitiate(config, deploymentInitiateInput);
-    await uploadFiles(config, deployment.deploymentTargets);
+    deployment = await deploymentInitiate({
+      config,
+      input: deploymentInitiateInput,
+      logger
+    });
+    await uploadFiles({ config, targets: deployment.deploymentTargets, logger });
     const deploymentCompleteOp = await deploymentComplete(
       config,
       deployment.deployment.id
     );
+    if (!config.skipHealthCheck) {
+      await healthCheck({
+        config,
+        url: deploymentCompleteOp.deployment.url,
+        logger,
+        hooks
+      });
+    }
     const urlMessage = config.publicDeployment ? "Public" : "Private";
     outputSuccess(
       `Deployment complete.
 ${urlMessage} preview URL: ${deploymentCompleteOp.deployment.url}`,
-      stderrLogger
+      logger
     );
     if (metadata.name !== "none") {
       outputInfo(deploymentCompleteOp.deployment.url);
     }
+    return deploymentCompleteOp.deployment.url;
   } catch (error) {
     if (!(error instanceof Error)) {
       console.error("Unknown error", error);
-      return;
+      return Promise.reject(new Error("Unknown error"));
     }
-    if (build.id && !buildCompleted) {
+    if (error instanceof HealthCheckError) {
+      outputWarn(error.message, logger);
+    } else if (build.id && !buildCompleted) {
       outputWarn(
         `Build failed with: ${error.message}, cancelling build.`,
-        stderrLogger
+        logger
       );
-      await buildCancel(config, build.id, error.message).catch((err) => {
+      await buildCancel({
+        config,
+        buildId: build.id,
+        reason: error.message,
+        logger
+      }).catch((err) => {
         if (err instanceof Error) {
-          outputWarn(`Failed to cancel build: ${err.message}`, stderrLogger);
+          outputWarn(`Failed to cancel build: ${err.message}`, logger);
         }
       });
     } else if (deployment?.deployment.id) {
       outputWarn(
         `Deployment failed with: ${error.message}, cancelling deployment.`,
-        stderrLogger
+        logger
       );
-      await deploymentCancel(
+      await deploymentCancel({
         config,
-        deployment.deployment.id,
-        DeploymentCancelReason.Failed
-      ).catch((err) => {
+        deploymentId: deployment.deployment.id,
+        reason: DeploymentCancelReason.Failed,
+        logger
+      }).catch((err) => {
         if (err instanceof Error) {
-          outputWarn(
-            `Failed to cancel deployment: ${err.message}`,
-            stderrLogger
-          );
+          outputWarn(`Failed to cancel deployment: ${err.message}`, logger);
         }
       });
     }
-    consoleError(error.message);
+    return Promise.reject(error);
   }
 }
 

package/dist/deploy/metadata.d.ts

@@ -1,11 +1,12 @@
 import { CIMetadata } from '@shopify/cli-kit/node/context/local';
-import { DeployConfig, EnvironmentInput } from './types.js';
+import { Logger } from '@shopify/cli-kit/node/output';
+import { DeploymentConfig, EnvironmentInput } from './types.js';
 
 type Metadata = CIMetadata & {
     name: string;
 };
-declare function getMetadata(config: DeployConfig): Promise<Metadata>;
-declare function getEnvironmentInput(config: DeployConfig, metadata: CIMetadata): EnvironmentInput | undefined;
+declare function getMetadata(config: DeploymentConfig, logger: Logger): Promise<Metadata>;
+declare function getEnvironmentInput(config: DeploymentConfig, metadata: CIMetadata): EnvironmentInput | undefined;
 declare function createLabels(metadata: Metadata): string[];
 
 export { createLabels, getEnvironmentInput, getMetadata };

package/dist/deploy/metadata.js

@@ -1,9 +1,9 @@
 import { ciPlatform } from '@shopify/cli-kit/node/context/local';
 import { getLatestGitCommit } from '@shopify/cli-kit/node/git';
 import { outputWarn } from '@shopify/cli-kit/node/output';
-import { stderrLogger, maxLabelLength } from '../utils/utils.js';
+import { maxLabelLength } from '../utils/utils.js';
 
-async function getMetadata(config) {
+async function getMetadata(config, logger) {
   const ciInfo = ciPlatform();
   let metadata = {};
   if (ciInfo.isCI && ciInfo.name !== "unknown") {
@@ -19,7 +19,7 @@ async function getMetadata(config) {
         commitMessage: gitCommit.message
       };
     } catch (error) {
-      outputWarn("No CI metadata loaded from environment", stderrLogger);
+      outputWarn("No CI metadata loaded from environment", logger);
     }
   }
   return {

package/dist/deploy/metadata.test.js

@@ -1,7 +1,7 @@
 import { getLatestGitCommit } from '@shopify/cli-kit/node/git';
 import { ciPlatform } from '@shopify/cli-kit/node/context/local';
 import { vi, describe, test, expect } from 'vitest';
-import { maxLabelLength } from '../utils/utils.js';
+import { stderrLogger, maxLabelLength } from '../utils/utils.js';
 import { createTestConfig } from '../utils/test-helper.js';
 import { getMetadata, getEnvironmentInput, createLabels } from './metadata.js';
 
@@ -19,7 +19,7 @@ describe("getMetadata", () => {
       }
     });
     const testConfig = createTestConfig("/tmp/deploymentRoot/");
-    const metadataResult = await getMetadata(testConfig);
+    const metadataResult = await getMetadata(testConfig, stderrLogger);
     expect(metadataResult.actor).toBe("circle_actor");
     expect(metadataResult.commitSha).toBe("circle_sha");
     expect(metadataResult.name).toBe("circle");
@@ -41,7 +41,7 @@ describe("getMetadata", () => {
       version: "custom_version",
       url: "custom_url"
     };
-    const metadataResult = await getMetadata(testConfig);
+    const metadataResult = await getMetadata(testConfig, stderrLogger);
     expect(metadataResult.actor).toBe("custom_user");
     expect(metadataResult.commitSha).toBe("custom_version");
     expect(metadataResult.name).toBe("circle");
@@ -61,7 +61,7 @@ describe("getMetadata", () => {
       body: "gh_body"
     });
     const testConfig = createTestConfig("/tmp/deploymentRoot/");
-    const metadataResult = await getMetadata(testConfig);
+    const metadataResult = await getMetadata(testConfig, stderrLogger);
     expect(metadataResult.actor).toBe("gh_author");
     expect(metadataResult.commitSha).toBe("gh_hash");
     expect(metadataResult.name).toBe("none");

package/dist/deploy/types.d.ts

@@ -5,12 +5,24 @@ interface Build {
 interface ClientError extends Error {
     statusCode: number;
 }
-interface DeployConfig {
+interface DeploymentHooks {
+    onBuildStart?: () => void;
+    onBuildComplete?: () => void;
+    onBuildError?: (error: Error) => void;
+    onHealthCheckStart?: () => void;
+    onHealthCheckComplete?: () => void;
+    onHealthCheckError?: (error: Error) => void;
+    onUploadFilesStart?: () => void;
+    onUploadFilesComplete?: () => void;
+}
+interface DeploymentConfig {
     assetsDir?: string;
     buildCommand: string;
+    buildOutput: boolean;
     deploymentToken: DeploymentToken;
     deploymentUrl: string;
     environmentTag?: string;
+    healthCheckMaxDuration: number;
     metadata: {
         user?: string;
         version?: string;
@@ -19,6 +31,7 @@ interface DeployConfig {
     publicDeployment: boolean;
     rootPath?: string;
     skipBuild: boolean;
+    skipHealthCheck: boolean;
     workerDir?: string;
     workerOnly: boolean;
 }
@@ -49,5 +62,7 @@ declare enum FileType {
 interface OxygenError {
     message: string;
 }
+declare class HealthCheckError extends Error {
+}
 
-export { Build, ClientError, DeployConfig, DeploymentManifestFile, DeploymentToken, EnvironmentInput, FileType, OxygenError };
+export { Build, ClientError, DeploymentConfig, DeploymentHooks, DeploymentManifestFile, DeploymentToken, EnvironmentInput, FileType, HealthCheckError, OxygenError };

package/dist/deploy/types.js

@@ -3,5 +3,7 @@ var FileType = /* @__PURE__ */ ((FileType2) => {
   FileType2["Asset"] = "ASSET";
   return FileType2;
 })(FileType || {});
+class HealthCheckError extends Error {
+}
 
-export { FileType };
+export { FileType, HealthCheckError };

package/dist/deploy/upload-files.d.ts

@@ -1,6 +1,13 @@
-import { DeployConfig } from './types.js';
+import { Logger } from '@shopify/cli-kit/node/output';
+import { DeploymentConfig, DeploymentHooks } from './types.js';
 import { DeploymentTargetResponse } from './graphql/deployment-initiate.js';
 
-declare function uploadFiles(config: DeployConfig, targets: DeploymentTargetResponse[]): Promise<void>;
+interface UploadFilesOptions {
+    config: DeploymentConfig;
+    hooks?: DeploymentHooks;
+    logger: Logger;
+    targets: DeploymentTargetResponse[];
+}
+declare function uploadFiles(options: UploadFilesOptions): Promise<void>;
 
 export { uploadFiles };

package/dist/deploy/upload-files.js

@@ -3,14 +3,17 @@ import { createFileReadStream } from '@shopify/cli-kit/node/fs';
 import { outputInfo, outputCompleted } from '@shopify/cli-kit/node/output';
 import { joinPath } from '@shopify/cli-kit/node/path';
 import { mapLimit } from 'async';
-import { stderrLogger, deployDefaults } from '../utils/utils.js';
+import { deployDefaults } from '../utils/utils.js';
 
-async function uploadFiles(config, targets) {
-  outputInfo(`Uploading ${targets.length} files...`, stderrLogger);
+async function uploadFiles(options) {
+  const { config, logger, targets, hooks } = options;
+  outputInfo(`Uploading ${targets.length} files...`, logger);
+  hooks?.onUploadFilesStart?.();
   return mapLimit(targets, 6, async (target) => {
     await uploadFile(config, target);
   }).then(() => {
-    outputCompleted(`Files uploaded successfully`, stderrLogger);
+    hooks?.onUploadFilesComplete?.();
+    outputCompleted(`Files uploaded successfully`, logger);
   });
 }
 async function uploadFile(config, target) {