@shopify/oxygen-cli 1.0.2

package/dist/deploy/graphql/deployment-initiate.d.ts

@@ -0,0 +1,28 @@
+import { OxygenError } from '../types.js';
+
+declare const DeploymentInitiateQuery = "\n  mutation DeploymentInitiate($buildId: ID, $environment: EnvironmentSelectorInput, $labels: [String!], $files: [FileInput!]!) {\n    deploymentInitiate(buildId: $buildId, environment: $environment, labels: $labels, files: $files) {\n      deployment {\n        id\n        status\n      }\n      deploymentTargets {\n        filePath\n        fileSize\n        uploadUrl\n        fileType\n        parameters {\n          name\n          value\n        }\n      }\n      userErrors {\n        message\n      }\n    }\n  }\n";
+interface DeploymentInitiateQueryData {
+    deploymentInitiate: DeploymentInitiateResponse;
+}
+interface DeploymentInitiateResponse {
+    deployment: Deployment;
+    deploymentTargets: DeploymentTargetResponse[];
+    userErrors: OxygenError[];
+}
+interface DeploymentTargetResponse {
+    filePath: string;
+    fileSize: number;
+    uploadUrl: string;
+    fileType: string;
+    parameters: DeploymentInitiateParameters[] | null;
+}
+interface Deployment {
+    id: string;
+    status: string;
+}
+interface DeploymentInitiateParameters {
+    name: string;
+    value: string;
+}
+
+export { DeploymentInitiateQuery, DeploymentInitiateQueryData, DeploymentInitiateResponse, DeploymentTargetResponse };

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

@@ -0,0 +1,25 @@
+const DeploymentInitiateQuery = `
+  mutation DeploymentInitiate($buildId: ID, $environment: EnvironmentSelectorInput, $labels: [String!], $files: [FileInput!]!) {
+    deploymentInitiate(buildId: $buildId, environment: $environment, labels: $labels, files: $files) {
+      deployment {
+        id
+        status
+      }
+      deploymentTargets {
+        filePath
+        fileSize
+        uploadUrl
+        fileType
+        parameters {
+          name
+          value
+        }
+      }
+      userErrors {
+        message
+      }
+    }
+  }
+`;
+
+export { DeploymentInitiateQuery };

package/dist/deploy/index.d.ts

@@ -0,0 +1,5 @@
+import { DeployConfig } from './types.js';
+
+declare function createDeploy(config: DeployConfig): Promise<void>;
+
+export { createDeploy };

package/dist/deploy/index.js

@@ -0,0 +1,74 @@
+import { outputSuccess, outputWarn, consoleError } from '@shopify/cli-kit/node/output';
+import { verifyConfig } 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 { deploymentCancel } from './deployment-cancel.js';
+import { uploadFiles } from './upload-files.js';
+import { buildProject } from './build-project.js';
+import { getMetadata, createLabels, getEnvironmentInput } from './metadata.js';
+
+async function createDeploy(config) {
+  const build = {};
+  let buildCompleted;
+  let deployment;
+  try {
+    const metadata = await getMetadata(config);
+    const labels = createLabels(metadata);
+    const environment = getEnvironmentInput(config, metadata);
+    if (!config.workerOnly && !config.skipBuild) {
+      const buildInitiateResponse = await buildInitiate(
+        config,
+        environment,
+        labels
+      );
+      build.id = buildInitiateResponse.build.id;
+      build.assetPath = buildInitiateResponse.build.assetPath;
+    }
+    if (!config.skipBuild) {
+      await buildProject(config, build.assetPath);
+      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);
+    const deploymentCompleteOp = await deploymentComplete(
+      config,
+      deployment.deployment.id
+    );
+    outputSuccess(
+      `Deployment complete: ${deploymentCompleteOp.deployment.url}`
+    );
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      console.error("Unknown error", error);
+      return;
+    }
+    if (build.id && !buildCompleted) {
+      outputWarn(`Build failed with: ${error.message}, cancelling build.`);
+      await buildCancel(config, build.id, error.message).catch((err) => {
+        if (err instanceof Error) {
+          outputWarn(`Failed to cancel build: ${err.message}`);
+        }
+      });
+    } else if (deployment?.deployment.id) {
+      outputWarn(
+        `Deployment failed with: ${error.message}, cancelling deployment.`
+      );
+      await deploymentCancel(config, deployment.deployment.id, "failed").catch(
+        (err) => {
+          if (err instanceof Error) {
+            outputWarn(`Failed to cancel deployment: ${err.message}`);
+          }
+        }
+      );
+    }
+    consoleError(error.message);
+  }
+}
+
+export { createDeploy };

package/dist/deploy/metadata.d.ts

@@ -0,0 +1,11 @@
+import { CIMetadata } from '@shopify/cli-kit/node/context/local';
+import { DeployConfig, 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 createLabels(metadata: Metadata): string[];
+
+export { createLabels, getEnvironmentInput, getMetadata };

package/dist/deploy/metadata.js

@@ -0,0 +1,65 @@
+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 { maxLabelLength } from '../utils/utils.js';
+
+async function getMetadata(config) {
+  const ciInfo = ciPlatform();
+  let metadata = {};
+  if (ciInfo.isCI && ciInfo.name !== "unknown") {
+    metadata = ciInfo.metadata;
+  } else {
+    try {
+      const gitCommit = await getLatestGitCommit(config.rootPath);
+      const branch = gitCommit.refs.split(" ");
+      metadata = {
+        actor: gitCommit.author_name,
+        branch: branch[branch.length - 1],
+        commitSha: gitCommit.hash,
+        commitMessage: gitCommit.message
+      };
+    } catch (error) {
+      outputWarn("No CI metadata loaded from environment");
+    }
+  }
+  return {
+    name: ciInfo.isCI ? ciInfo.name : "unknown",
+    ...metadata,
+    actor: config.metadata.user ?? metadata.actor,
+    commitSha: config.metadata.version ?? metadata.commitSha,
+    url: config.metadata.url ?? metadata.url
+  };
+}
+function getEnvironmentInput(config, metadata) {
+  const tag = config.environmentTag || metadata.branch;
+  return tag ? { tag } : void 0;
+}
+function createLabels(metadata) {
+  const labels = [];
+  const checkLabel = (labelKey, labelValue) => {
+    if (labelValue.length > maxLabelLength) {
+      throw new Error(
+        `Provided ${labelKey} metadata exceeds maximum length (max ${maxLabelLength} characters).`
+      );
+    }
+    const label = `${labelKey}=${JSON.stringify(labelValue)}`;
+    labels.push(label);
+  };
+  if (metadata.name !== "unknown" && metadata.run) {
+    labels.push(`${metadata.name}-runId=${JSON.stringify(metadata.run)}`);
+  }
+  const keys = ["url", "actor", "commitSha"];
+  const keyMapping = {
+    actor: "user",
+    commitSha: "version"
+  };
+  keys.forEach((key) => {
+    if (metadata[key]) {
+      const labelKey = keyMapping[key] || key;
+      checkLabel(labelKey, metadata[key]);
+    }
+  });
+  return labels;
+}
+
+export { createLabels, getEnvironmentInput, getMetadata };

package/dist/deploy/metadata.test.d.ts

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

package/dist/deploy/metadata.test.js

@@ -0,0 +1,131 @@
+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 { createTestConfig } from '../utils/test-helper.js';
+import { getMetadata, getEnvironmentInput, createLabels } from './metadata.js';
+
+vi.mock("@shopify/cli-kit/node/context/local");
+vi.mock("@shopify/cli-kit/node/git");
+describe("getMetadata", () => {
+  test("should return custom metadata from environment", async () => {
+    vi.mocked(ciPlatform).mockReturnValueOnce({
+      isCI: true,
+      name: "circle",
+      metadata: {
+        actor: "circle_actor",
+        commitSha: "circle_sha",
+        url: "circle_url"
+      }
+    });
+    const testConfig = createTestConfig("/tmp/deploymentRoot/");
+    const metadataResult = await getMetadata(testConfig);
+    expect(metadataResult.actor).toBe("circle_actor");
+    expect(metadataResult.commitSha).toBe("circle_sha");
+    expect(metadataResult.name).toBe("circle");
+    expect(metadataResult.url).toBe("circle_url");
+  });
+  test("should return custom metadata when provided in config", async () => {
+    vi.mocked(ciPlatform).mockReturnValueOnce({
+      isCI: true,
+      name: "circle",
+      metadata: {
+        actor: "circle_actor",
+        commitSha: "circle_sha",
+        url: "circle_url"
+      }
+    });
+    const testConfig = createTestConfig("/tmp/deploymentRoot/");
+    testConfig.metadata = {
+      user: "custom_user",
+      version: "custom_version",
+      url: "custom_url"
+    };
+    const metadataResult = await getMetadata(testConfig);
+    expect(metadataResult.actor).toBe("custom_user");
+    expect(metadataResult.commitSha).toBe("custom_version");
+    expect(metadataResult.name).toBe("circle");
+    expect(metadataResult.url).toBe("custom_url");
+  });
+  test("should return commit data from latest commit through getLastestGitCommit", async () => {
+    vi.mocked(ciPlatform).mockReturnValueOnce({
+      isCI: false
+    });
+    vi.mocked(getLatestGitCommit).mockResolvedValueOnce({
+      author_name: "gh_author",
+      author_email: "test@github.com",
+      hash: "gh_hash",
+      message: "gh_message",
+      refs: "gh_refs",
+      date: "gh_date",
+      body: "gh_body"
+    });
+    const testConfig = createTestConfig("/tmp/deploymentRoot/");
+    const metadataResult = await getMetadata(testConfig);
+    expect(metadataResult.actor).toBe("gh_author");
+    expect(metadataResult.commitSha).toBe("gh_hash");
+    expect(metadataResult.name).toBe("unknown");
+    expect(metadataResult.url).toBe(void 0);
+  });
+});
+describe("getEnvironmentInput", () => {
+  test("should return environment tag from config", () => {
+    const testConfig = createTestConfig("/tmp/deploymentRoot/");
+    testConfig.environmentTag = "test_tag";
+    const metadata = {
+      branch: "test_branch"
+    };
+    const environmentInput = getEnvironmentInput(testConfig, metadata);
+    expect(environmentInput.tag).toBe("test_tag");
+  });
+  test("should return environment tag from metadata", () => {
+    const testConfig = createTestConfig("/tmp/deploymentRoot/");
+    delete testConfig.environmentTag;
+    const metadata = {
+      branch: "test_branch"
+    };
+    const environmentInput = getEnvironmentInput(testConfig, metadata);
+    expect(environmentInput.tag).toBe("test_branch");
+  });
+  test("should return undefined if no environment tag is provided", () => {
+    const testConfig = createTestConfig("/tmp/deploymentRoot/");
+    delete testConfig.environmentTag;
+    const metadata = {};
+    expect(getEnvironmentInput(testConfig, metadata)).toBe(void 0);
+  });
+});
+describe("createLabels", () => {
+  test("should return labels from metadata", () => {
+    const metadata = {
+      name: "circle",
+      run: "circle_1234",
+      url: "http://circleci.com/workflow/123",
+      actor: "circle_actor",
+      commitSha: "circle_sha"
+    };
+    const labels = [
+      'circle-runId="circle_1234"',
+      'url="http://circleci.com/workflow/123"',
+      'user="circle_actor"',
+      'version="circle_sha"'
+    ];
+    expect(createLabels(metadata)).toEqual(labels);
+  });
+  test("should return labels from metadata only for populated fields", () => {
+    const metadata = {
+      name: "circle",
+      run: "circle_run"
+    };
+    const labels = ['circle-runId="circle_run"'];
+    expect(createLabels(metadata)).toEqual(labels);
+  });
+  test("should throw when user metadata exceeds maximum length", () => {
+    const metadata = {
+      actor: "a".repeat(101),
+      name: "unknown"
+    };
+    expect(() => createLabels(metadata)).toThrow(
+      `Provided user metadata exceeds maximum length (max ${maxLabelLength} characters).`
+    );
+  });
+});

package/dist/deploy/types.d.ts

@@ -0,0 +1,52 @@
+interface Build {
+    id: string;
+    assetPath: string;
+}
+interface ClientError extends Error {
+    statusCode: number;
+}
+interface DeployConfig {
+    assetsDir?: string;
+    buildCommand: string;
+    deploymentToken: DeploymentToken;
+    deploymentUrl: string;
+    environmentTag?: string;
+    metadata: {
+        user?: string;
+        version?: string;
+        url?: string;
+    };
+    rootPath?: string;
+    skipBuild: boolean;
+    workerDir?: string;
+    workerOnly: boolean;
+}
+interface DeploymentToken {
+    accessToken: string;
+    allowedResource: string;
+    appId: string;
+    client: string;
+    expiresAt: string;
+    namespace: string;
+    namespaceId: string;
+}
+interface DeploymentManifestFile {
+    filePath: string;
+    fileSize: number;
+    mimeType: string;
+    fileHash: string;
+    fileType: string;
+}
+interface EnvironmentInput {
+    handle?: string;
+    tag?: string;
+}
+declare enum FileType {
+    Worker = "WORKER",
+    Asset = "ASSET"
+}
+interface OxygenError {
+    message: string;
+}
+
+export { Build, ClientError, DeployConfig, DeploymentManifestFile, DeploymentToken, EnvironmentInput, FileType, OxygenError };

package/dist/deploy/types.js

@@ -0,0 +1,7 @@
+var FileType = /* @__PURE__ */ ((FileType2) => {
+  FileType2["Worker"] = "WORKER";
+  FileType2["Asset"] = "ASSET";
+  return FileType2;
+})(FileType || {});
+
+export { FileType };

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

@@ -0,0 +1,6 @@
+import { DeployConfig } from './types.js';
+import { DeploymentTargetResponse } from './graphql/deployment-initiate.js';
+
+declare function uploadFiles(config: DeployConfig, targets: DeploymentTargetResponse[]): Promise<void>;
+
+export { uploadFiles };

package/dist/deploy/upload-files.js

@@ -0,0 +1,156 @@
+import { formData, fetch } from '@shopify/cli-kit/node/http';
+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 { deployDefaults } from '../utils/utils.js';
+
+async function uploadFiles(config, targets) {
+  outputInfo(`Uploading ${targets.length} files...`);
+  return mapLimit(targets, 6, async (target) => {
+    await uploadFile(config, target);
+  }).then(() => {
+    outputCompleted(`Files uploaded successfully`);
+  });
+}
+async function uploadFile(config, target) {
+  const localFolderPath = target.fileType === "WORKER" ? joinPath(config.rootPath, config.workerDir) : joinPath(config.rootPath, config.assetsDir);
+  if (target.parameters !== null && target.parameters.length > 0) {
+    const form = formData();
+    target.parameters.forEach((param) => {
+      form.append(param.name, param.value);
+    });
+    form.append(
+      "file",
+      createFileReadStream(joinPath(localFolderPath, target.filePath))
+    );
+    await formUpload(form, target);
+  } else {
+    const initData = await initiateResumableUpload(target);
+    await performResumableUpload(
+      joinPath(localFolderPath, target.filePath),
+      initData
+    );
+  }
+}
+async function formUpload(form, target, attemptNumber = 0) {
+  try {
+    const timeoutDuration = 6e4;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+      controller.abort();
+    }, timeoutDuration);
+    const response = await fetch(target.uploadUrl, {
+      method: "POST",
+      body: form,
+      signal: controller.signal,
+      headers: {
+        Connection: "keep-alive"
+      }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      throw new Error(`${response.status}`);
+    }
+  } catch (err) {
+    if (isErrorCode(err, "ENOENT")) {
+      throw new Error(`File not found: ${target.filePath}`);
+    }
+    if (attemptNumber < Number(deployDefaults.maxUploadAttempts)) {
+      await formUpload(form, target, attemptNumber + 1);
+    } else {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`Request timeout whilst uploading ${target.filePath}`);
+      }
+      throw new Error(`Failed to upload file ${target.filePath}`);
+    }
+  }
+}
+async function initiateResumableUpload(target) {
+  return fetch(target.uploadUrl, {
+    method: "POST",
+    headers: {
+      "x-goog-resumable": "start",
+      "X-Goog-Content-Length-Range": `0,${target.fileSize}`,
+      "User-Agent": "oxygen-cli"
+    }
+  }).then((res) => {
+    return {
+      sessionUri: res.headers.get("x-guploader-uploadid"),
+      location: res.headers.get("location"),
+      target
+    };
+  }).catch((err) => {
+    throw new Error(
+      `Failed to initiate resumable upload for file ${target.filePath} (status code ${err.statusCode})`
+    );
+  });
+}
+async function performResumableUpload(localFilePath, initData, startByte = 0, attemptNumber = 0) {
+  await uploadResumable(initData.location, localFilePath, startByte).catch(
+    async (err) => {
+      if (isErrorCode(err, "ENOENT")) {
+        throw new Error(`File not found: ${initData.target.filePath}`);
+      }
+      if (err && attemptNumber >= Number(deployDefaults.maxResumabeUploadAttempts)) {
+        throw new Error(
+          `Failed to upload file ${initData.target.filePath} after ${deployDefaults.maxResumabeUploadAttempts} attempts`
+        );
+      }
+      const status = await resumableUploadStatus(
+        initData.location,
+        initData.target.fileSize
+      );
+      if (!status.complete) {
+        const nextAttemptStartByte = status.lastReceivedByte;
+        const attempt = attemptNumber + 1;
+        await performResumableUpload(
+          localFilePath,
+          initData,
+          nextAttemptStartByte,
+          attempt
+        );
+      }
+    }
+  );
+}
+async function uploadResumable(location, filePath, lastReceivedByte) {
+  const file = createFileReadStream(filePath, { start: lastReceivedByte });
+  return fetch(location, {
+    method: "PUT",
+    body: file
+  }).then((res) => {
+    return res.status;
+  });
+}
+async function resumableUploadStatus(location, fileSize) {
+  const getLastByte = (range) => {
+    if (!range || range.split("-").length !== 2)
+      return 0;
+    const rangeParts = range.split("-");
+    return parseInt(rangeParts[1], 10);
+  };
+  return fetch(location, {
+    method: "PUT",
+    headers: {
+      "Content-Length": "0",
+      "Content-Range": `bytes */${fileSize}`
+    }
+  }).then((res) => {
+    return {
+      complete: res.status === 200,
+      lastReceivedByte: getLastByte(res.headers.get("range"))
+    };
+  }).catch((err) => {
+    console.error(err);
+    return {
+      complete: false,
+      lastReceivedByte: 0
+    };
+  });
+}
+function isErrorCode(err, code) {
+  return err instanceof Error && "code" in err && err.code === code;
+}
+
+export { uploadFiles };

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

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