@shopify/oxygen-cli 1.0.2

package/dist/deploy/upload-files.test.js

@@ -0,0 +1,194 @@
+import { Readable } from 'stream';
+import { fetch } from '@shopify/cli-kit/node/http';
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { Response } from 'node-fetch';
+import { createTestConfig } from '../utils/test-helper.js';
+import { deployDefaults } from '../utils/utils.js';
+import { uploadFiles } from './upload-files.js';
+
+class NamedReadable extends Readable {
+  name = "dummy";
+  _read() {
+  }
+}
+vi.mock("@shopify/cli-kit/node/output");
+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/fs", () => {
+  return {
+    createFileReadStream: vi.fn(() => {
+      const readable = new NamedReadable();
+      readable.push("dummy");
+      readable.emit("end");
+      return readable;
+    })
+  };
+});
+vi.mock("fs", () => {
+  return {
+    createReadStream: vi.fn(() => {
+      const readable = new NamedReadable();
+      readable.push("dummy");
+      readable.emit("end");
+      return readable;
+    })
+  };
+});
+const testConfig = createTestConfig("/tmp/deploymentRoot");
+describe("UploadFiles", () => {
+  beforeEach(() => {
+    vi.mocked(fetch).mockReset();
+  });
+  it("Performs a form upload", async () => {
+    const response = new Response();
+    vi.mocked(fetch).mockResolvedValueOnce(response);
+    const testWorkerUpload = [
+      {
+        filePath: "index.js",
+        fileSize: 1,
+        uploadUrl: "https://storage.googleapis.com/the-bucket/",
+        fileType: "WORKER",
+        parameters: [{ name: "someName", value: "someValue" }]
+      }
+    ];
+    await uploadFiles(testConfig, testWorkerUpload);
+    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(fetch)).toHaveBeenCalledWith(
+      "https://storage.googleapis.com/the-bucket/",
+      expect.objectContaining({
+        method: "POST",
+        body: expect.objectContaining({
+          _streams: expect.arrayContaining([
+            expect.stringContaining('name="someName"'),
+            expect.stringMatching("someValue")
+          ]),
+          _valuesToMeasure: expect.arrayContaining([
+            expect.objectContaining({ name: "dummy" })
+          ])
+        })
+      })
+    );
+  });
+  it("Retries a failed form upload until the max upload attempts then throws", async () => {
+    vi.mocked(fetch).mockRejectedValue(new Error("some error"));
+    const testWorkerUpload = [
+      {
+        filePath: "index.js",
+        fileSize: 1,
+        uploadUrl: "https://storage.googleapis.com/the-bucket/",
+        fileType: "WORKER",
+        parameters: [{ name: "someName", value: "someValue" }]
+      }
+    ];
+    await expect(uploadFiles(testConfig, testWorkerUpload)).rejects.toThrow(
+      "Failed to upload file index.js"
+    );
+    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(
+      Number(deployDefaults.maxUploadAttempts) + 1
+    );
+  });
+  it("Performs a resumable upload", async () => {
+    const headers = {
+      "x-guploader-uploadid": "some-id",
+      location: "https://upload-it-here.com/"
+    };
+    const response = new Response(null, { headers });
+    vi.mocked(fetch).mockResolvedValue(response);
+    const testWorkerUpload = [
+      {
+        filePath: "index.js",
+        fileSize: 1,
+        uploadUrl: "https://storage.googleapis.com/the-bucket/",
+        fileType: "WORKER",
+        parameters: null
+      }
+    ];
+    await uploadFiles(testConfig, testWorkerUpload);
+    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(2);
+    const secondCall = vi.mocked(fetch).mock.calls[1];
+    expect(secondCall[0]).toBe("https://upload-it-here.com/");
+    const validateRequestBody = (req) => {
+      return req.method === "PUT" && req.body instanceof NamedReadable;
+    };
+    expect(validateRequestBody(secondCall[1])).toBe(true);
+  });
+  it("Resumes a resumable upload", async () => {
+    console.error = () => {
+    };
+    let fetchCounter = 0;
+    vi.mocked(fetch).mockImplementation(async () => {
+      fetchCounter++;
+      if (fetchCounter === 1) {
+        const headers = {
+          "x-guploader-uploadid": "some-id",
+          location: "https://upload-it-here.com/"
+        };
+        const response = new Response(null, { headers });
+        return Promise.resolve(response);
+      } else if (fetchCounter === 4) {
+        return Promise.resolve(new Response(null, { status: 200 }));
+      } else {
+        return Promise.reject(new Error("some error"));
+      }
+    });
+    const testWorkerUpload = [
+      {
+        filePath: "index.js",
+        fileSize: 1,
+        uploadUrl: "https://storage.googleapis.com/the-bucket/",
+        fileType: "WORKER",
+        parameters: null
+      }
+    ];
+    await uploadFiles(testConfig, testWorkerUpload);
+    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(4);
+    const statusCall = vi.mocked(fetch).mock.calls[2];
+    expect(statusCall[0]).toBe("https://upload-it-here.com/");
+    expect(statusCall[1]).toMatchObject({
+      method: "PUT",
+      headers: {
+        "Content-Range": "bytes */1",
+        "Content-Length": "0"
+      }
+    });
+  });
+  it("Throws when a resumable upload fails after exhausting attempt count", async () => {
+    console.error = () => {
+    };
+    let fetchCounter = 0;
+    vi.mocked(fetch).mockImplementation(async () => {
+      fetchCounter++;
+      if (fetchCounter === 1) {
+        const headers = {
+          "x-guploader-uploadid": "some-id",
+          location: "https://upload-it-here.com/"
+        };
+        const response = new Response(null, { headers });
+        return Promise.resolve(response);
+      } else {
+        return Promise.reject(new Error("some error"));
+      }
+    });
+    const testWorkerUpload = [
+      {
+        filePath: "index.js",
+        fileSize: 1,
+        uploadUrl: "https://storage.googleapis.com/the-bucket/",
+        fileType: "WORKER",
+        parameters: null
+      }
+    ];
+    await expect(uploadFiles(testConfig, testWorkerUpload)).rejects.toThrow(
+      `Failed to upload file index.js after ${deployDefaults.maxResumabeUploadAttempts} attempts`
+    );
+    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(
+      // for each attempt, we make two calls to fetch, plus the initial attempt makes two calls
+      Number(deployDefaults.maxResumabeUploadAttempts) * 2 + 2
+    );
+  });
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare function runOxygenCLI(): Promise<void>;
+
+export { runOxygenCLI as default };

package/dist/index.js

@@ -0,0 +1,11 @@
+import { runCLI } from '@shopify/cli-kit/node/cli';
+
+async function runOxygenCLI() {
+  await runCLI({
+    moduleURL: import.meta.url,
+    development: false
+  });
+}
+var src_default = runOxygenCLI;
+
+export { src_default as default };

package/dist/oxygen-cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/oxygen-cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import runCLI from './index.js';
+
+process.removeAllListeners("warning");
+runCLI();

package/dist/utils/test-helper.d.ts

@@ -0,0 +1,14 @@
+import { DeployConfig } from '../deploy/types.js';
+
+declare const testToken: {
+    accessToken: string;
+    allowedResource: string;
+    appId: string;
+    client: string;
+    expiresAt: string;
+    namespace: string;
+    namespaceId: string;
+};
+declare function createTestConfig(rootFolder: string): DeployConfig;
+
+export { createTestConfig, testToken };

package/dist/utils/test-helper.js

@@ -0,0 +1,27 @@
+import { deployDefaults } from './utils.js';
+
+const testToken = {
+  accessToken: "some_token",
+  allowedResource: "gid://oxygen-hub/Namespace/1",
+  appId: "gid://oxygen-hub/App/1",
+  client: "gid://oxygen-hub/Client/1",
+  expiresAt: "2023-04-08T09:38:50.368Z",
+  namespace: "fresh-namespace",
+  namespaceId: "gid://oxygen-hub/Namespace/1"
+};
+function createTestConfig(rootFolder) {
+  return {
+    assetsDir: "/assets/",
+    buildCommand: String(deployDefaults.buildCommandDefault),
+    deploymentToken: testToken,
+    environmentTag: "environment",
+    deploymentUrl: "https://localhost:3000",
+    metadata: {},
+    rootPath: rootFolder,
+    skipBuild: false,
+    workerDir: "/worker/",
+    workerOnly: false
+  };
+}
+
+export { createTestConfig, testToken };

package/dist/utils/utils.d.ts

@@ -0,0 +1,20 @@
+import { DeployConfig, ClientError, DeploymentToken } from '../deploy/types.js';
+
+declare const deployDefaults: {
+    [key: string]: string | number;
+};
+declare function errorHandler(error: any): void;
+declare function getBuildCommandFromLockFile(config: DeployConfig): string;
+declare enum Header {
+    OxygenNamespaceHandle = "X-Oxygen-Namespace-Handle"
+}
+declare function isClientError(error: unknown): error is ClientError;
+declare const maxLabelLength = 90;
+declare function parseToken(inputToken: string): DeploymentToken;
+interface VerifyConfigParams {
+    config: DeployConfig;
+    performedBuild?: boolean;
+}
+declare function verifyConfig({ config, performedBuild, }: VerifyConfigParams): Promise<void>;
+
+export { Header, deployDefaults, errorHandler, getBuildCommandFromLockFile, isClientError, maxLabelLength, parseToken, verifyConfig };

package/dist/utils/utils.js

@@ -0,0 +1,126 @@
+import { fileExistsSync, fileExists } from '@shopify/cli-kit/node/fs';
+import { outputWarn, outputInfo } from '@shopify/cli-kit/node/output';
+import { joinPath } from '@shopify/cli-kit/node/path';
+import { AbortError } from '@shopify/cli-kit/node/error';
+
+const deployDefaults = {
+  assetsDirDefault: "dist/client/",
+  buildCommandDefault: "yarn build",
+  maxUploadAttempts: 3,
+  maxResumabeUploadAttempts: 9,
+  workerDirDefault: "dist/worker/"
+};
+function errorHandler(error) {
+  if (isClientError(error)) {
+    if (error.statusCode === 401) {
+      throw new AbortError(
+        "You are not authorized to perform this action. Please check your deployment token."
+      );
+    }
+    if (error.statusCode === 429) {
+      throw new AbortError(
+        "You've made too many requests. Please try again later"
+      );
+    }
+  }
+  if (error instanceof AbortError && error.message.includes("503")) {
+    throw new AbortError(
+      "The server is currently unavailable. Please try again later."
+    );
+  }
+}
+function getBuildCommandFromLockFile(config) {
+  const lockFileBuildCommands = /* @__PURE__ */ new Map([
+    ["package-lock.json", "npm run build"],
+    ["pnpm-lock.yaml", "pnpm run build"],
+    ["yarn.lock", "yarn build"]
+  ]);
+  const foundLockFiles = [];
+  for (const [lockFileName, buildCommand] of lockFileBuildCommands) {
+    if (fileExistsSync(joinPath(config.rootPath, lockFileName))) {
+      foundLockFiles.push({ lockFileName, buildCommand });
+    }
+  }
+  if (foundLockFiles.length > 1) {
+    const lockFilesList = foundLockFiles.map(({ lockFileName }) => lockFileName).join(", ");
+    outputWarn(`Warning: Multiple lock files found: (${lockFilesList}).`);
+  }
+  if (foundLockFiles.length > 0) {
+    const { lockFileName, buildCommand } = foundLockFiles[0];
+    const infoMsg = foundLockFiles.length > 1 ? "" : `Found: ${lockFileName}. `;
+    outputInfo(
+      `${infoMsg}Assuming "${buildCommand}" as build command. Use the buildCommand flag to override.`
+    );
+    return buildCommand;
+  }
+  return String(deployDefaults.buildCommandDefault);
+}
+var Header = /* @__PURE__ */ ((Header2) => {
+  Header2["OxygenNamespaceHandle"] = "X-Oxygen-Namespace-Handle";
+  return Header2;
+})(Header || {});
+function isClientError(error) {
+  return typeof error === "object" && error !== null && "statusCode" in error;
+}
+const maxLabelLength = 90;
+function parseToken(inputToken) {
+  try {
+    const decodedToken = Buffer.from(inputToken, "base64").toString("utf-8");
+    const rawToken = JSON.parse(decodedToken);
+    return convertKeysToCamelCase(rawToken);
+  } catch (error) {
+    throw new Error(
+      `Error processing deployment token. Please check your token and try again.`
+    );
+  }
+}
+async function verifyConfig({
+  config,
+  performedBuild = false
+}) {
+  const { rootPath, workerDir, assetsDir, skipBuild, workerOnly } = config;
+  const checkPaths = {
+    root: rootPath
+  };
+  if (skipBuild || performedBuild) {
+    checkPaths.worker = joinPath(rootPath, workerDir);
+    if (!workerOnly) {
+      checkPaths.assets = joinPath(rootPath, assetsDir);
+    }
+  }
+  for (const pathType of Object.keys(checkPaths)) {
+    await checkPath(checkPaths[pathType], pathType);
+  }
+  const addressRegex = /^(http|https):\/\/(?:[\w-]+\.)*[\w-]+|(?:http|https):\/\/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/;
+  if (!addressRegex.test(config.deploymentUrl)) {
+    throw new Error(`Invalid deployment service URL: ${config.deploymentUrl}`);
+  }
+}
+async function checkPath(path, pathType) {
+  if (!await fileExists(path)) {
+    if (pathType === "assets") {
+      outputWarn(
+        `Use the "workerOnly" flag to perform a worker-only deployment.`
+      );
+    }
+    throw new Error(`Path not found: ${path}`);
+  }
+}
+function convertKeysToCamelCase(obj) {
+  if (typeof obj === "object") {
+    return Object.keys(obj).reduce((result, key) => {
+      const camelCaseKey = key.replace(
+        /([-_][a-z])/gi,
+        ($1) => $1.toUpperCase().replace("-", "").replace("_", "")
+      );
+      if (obj[key] === void 0) {
+        throw new Error(`Invalid token: ${key} is undefined`);
+      }
+      result[camelCaseKey] = convertKeysToCamelCase(obj[key]);
+      return result;
+    }, {});
+  }
+  return obj;
+}
+
+export { Header, deployDefaults, errorHandler, getBuildCommandFromLockFile, isClientError, maxLabelLength, parseToken, verifyConfig };

package/dist/utils/utils.test.d.ts

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

package/dist/utils/utils.test.js

@@ -0,0 +1,154 @@
+import { mkdir, rmdir, touchFile } from '@shopify/cli-kit/node/fs';
+import { joinPath } from '@shopify/cli-kit/node/path';
+import { outputInfo, outputWarn } from '@shopify/cli-kit/node/output';
+import { vi, beforeAll, afterAll, describe, test, expect } from 'vitest';
+import { createTestConfig, testToken } from './test-helper.js';
+import * as utils from './utils.js';
+
+const randomString = Math.random().toString(36).substring(7);
+const rootFolder = `/tmp/${randomString}/`;
+const testConfig = createTestConfig(rootFolder);
+vi.mock("@shopify/cli-kit/node/output");
+beforeAll(async () => {
+  await mkdir(rootFolder);
+  await mkdir(`${rootFolder}/worker`);
+  await mkdir(`${rootFolder}/assets`);
+});
+afterAll(async () => {
+  await rmdir(`${rootFolder}/worker`, { force: true });
+  await rmdir(`${rootFolder}/assets`, { force: true });
+  await rmdir(rootFolder, { force: true });
+});
+describe("getBuildCommandFromLockfile", () => {
+  test("getBuildCommandFromLockfile returns the default build command without a lockfile", () => {
+    const buildCommand = utils.getBuildCommandFromLockFile(testConfig);
+    expect(buildCommand).toBe(utils.deployDefaults.buildCommandDefault);
+  });
+  test("getBuildCommandFromLockfile returns the corresponding build command for a lockfile", async () => {
+    await touchFile(`${rootFolder}/pnpm-lock.yaml`);
+    const buildCommand = utils.getBuildCommandFromLockFile(testConfig);
+    expect(buildCommand).toBe("pnpm run build");
+    expect(outputInfo).toHaveBeenCalledWith(
+      'Found: pnpm-lock.yaml. Assuming "pnpm run build" as build command. Use the buildCommand flag to override.'
+    );
+  });
+  test("getBuildCommandFromLockfile the first build command and warns when multiple lockfiles are found", async () => {
+    await touchFile(`${rootFolder}/yarn.lock`);
+    const buildCommand = utils.getBuildCommandFromLockFile(testConfig);
+    expect(buildCommand).toBe("pnpm run build");
+    expect(outputInfo).toHaveBeenCalledWith(
+      'Assuming "pnpm run build" as build command. Use the buildCommand flag to override.'
+    );
+    expect(outputWarn).toHaveBeenCalledWith(
+      "Warning: Multiple lock files found: (pnpm-lock.yaml, yarn.lock)."
+    );
+  });
+});
+describe("parseToken", () => {
+  test("parseToken returns a token object when given a valid token", () => {
+    const base64EncodedToken = Buffer.from(JSON.stringify(testToken)).toString(
+      "base64"
+    );
+    const parsedToken = utils.parseToken(base64EncodedToken);
+    expect(parsedToken).toEqual(testToken);
+  });
+  test("parseToken throws when given an invalid token", () => {
+    try {
+      utils.parseToken("invalidToken");
+    } catch (err) {
+      expect(err).toEqual(
+        new Error(
+          `Error processing deployment token. Please check your token and try again.`
+        )
+      );
+    }
+  });
+});
+describe("verifyConfig", () => {
+  test("verifyConfig resolves with a valid configuration", async () => {
+    await expect(utils.verifyConfig({ config: testConfig })).resolves.toBe(
+      void 0
+    );
+  });
+  test("verifyConfig throws when the rootPath cannot be resolved", async () => {
+    const invalidConfig = {
+      ...testConfig,
+      rootPath: "/doesNotExist"
+    };
+    await expect(utils.verifyConfig({ config: invalidConfig })).rejects.toThrow(
+      new Error("Path not found: /doesNotExist")
+    );
+  });
+  test("verifyConfig throws when the assetsDir cannot be resolved", async () => {
+    const invalidConfig = {
+      ...testConfig,
+      assetsDir: "not_there",
+      skipBuild: true
+    };
+    await expect(utils.verifyConfig({ config: invalidConfig })).rejects.toThrow(
+      new Error(
+        `Path not found: ${joinPath(
+          invalidConfig.rootPath,
+          invalidConfig.assetsDir
+        )}`
+      )
+    );
+    expect(outputWarn).toHaveBeenCalledWith(
+      `Use the "workerOnly" flag to perform a worker-only deployment.`
+    );
+  });
+  test("verifyConfig throws when the workerDir cannot be resolved after a build", async () => {
+    const invalidConfig = {
+      ...testConfig,
+      skipBuild: false,
+      workerDir: "not_there",
+      workerOnly: true
+    };
+    await expect(
+      utils.verifyConfig({ config: invalidConfig, performedBuild: true })
+    ).rejects.toThrow(
+      new Error(
+        `Path not found: ${joinPath(
+          invalidConfig.rootPath,
+          invalidConfig.workerDir
+        )}`
+      )
+    );
+  });
+  test("verifyConfig throws when given an invalid deploymentUrl", async () => {
+    const invalidConfig = {
+      ...testConfig,
+      deploymentUrl: "invalidAddress"
+    };
+    await expect(utils.verifyConfig({ config: invalidConfig })).rejects.toThrow(
+      new Error("Invalid deployment service URL: invalidAddress")
+    );
+  });
+  test("parseToken returns a token object when given a valid token", () => {
+    const unparsedToken = {
+      access_token: "some_token",
+      allowed_resource: "gid://oxygen-hub/Namespace/1",
+      app_id: "gid://oxygen-hub/App/1",
+      client: "gid://oxygen-hub/Client/1",
+      expires_at: "2023-04-08T09:38:50.368Z",
+      namespace: "fresh-namespace",
+      namespace_id: "gid://oxygen-hub/Namespace/1"
+    };
+    const base64EncodedToken = Buffer.from(
+      JSON.stringify(unparsedToken)
+    ).toString("base64");
+    const parsedToken = utils.parseToken(base64EncodedToken);
+    expect(parsedToken).toEqual(testToken);
+  });
+  test("parseToken throws when given an invalid token", () => {
+    try {
+      utils.parseToken("invalidToken");
+    } catch (err) {
+      expect(err).toEqual(
+        new Error(
+          `Error processing deployment token. Please check your token and try again.`
+        )
+      );
+    }
+  });
+});

package/oclif.manifest.json

@@ -0,0 +1,108 @@
+{
+  "version": "1.0.2",
+  "commands": {
+    "oxygen:deploy": {
+      "id": "oxygen:deploy",
+      "description": "Creates a deployment to Oxygen",
+      "strict": true,
+      "pluginName": "@shopify/oxygen-cli",
+      "pluginAlias": "@shopify/oxygen-cli",
+      "pluginType": "core",
+      "hidden": false,
+      "aliases": [],
+      "flags": {
+        "token": {
+          "name": "token",
+          "type": "option",
+          "char": "t",
+          "description": "Oxygen deployment token",
+          "required": true,
+          "multiple": false
+        },
+        "rootPath": {
+          "name": "rootPath",
+          "type": "option",
+          "char": "r",
+          "description": "Root path",
+          "required": false,
+          "multiple": false,
+          "default": "./"
+        },
+        "environmentTag": {
+          "name": "environmentTag",
+          "type": "option",
+          "char": "e",
+          "description": "Tag of the environment to deploy to",
+          "required": false,
+          "multiple": false
+        },
+        "workerFolder": {
+          "name": "workerFolder",
+          "type": "option",
+          "char": "w",
+          "description": "Worker folder",
+          "required": false,
+          "multiple": false,
+          "default": "dist/worker/"
+        },
+        "assetsFolder": {
+          "name": "assetsFolder",
+          "type": "option",
+          "char": "a",
+          "description": "Assets folder",
+          "required": false,
+          "multiple": false,
+          "default": "dist/client/"
+        },
+        "workerOnly": {
+          "name": "workerOnly",
+          "type": "boolean",
+          "char": "o",
+          "description": "Worker only deployment",
+          "required": false,
+          "allowNo": false
+        },
+        "skipBuild": {
+          "name": "skipBuild",
+          "type": "boolean",
+          "char": "s",
+          "description": "Skip running build command",
+          "required": false,
+          "allowNo": false
+        },
+        "buildCommand": {
+          "name": "buildCommand",
+          "type": "option",
+          "char": "b",
+          "description": "Build command",
+          "required": false,
+          "multiple": false,
+          "default": "yarn build"
+        },
+        "metadataUrl": {
+          "name": "metadataUrl",
+          "type": "option",
+          "description": "URL that links to the deployment",
+          "required": false,
+          "multiple": false
+        },
+        "metadataUser": {
+          "name": "metadataUser",
+          "type": "option",
+          "description": "User that initiated the deployment",
+          "required": false,
+          "multiple": false
+        },
+        "metadataVersion": {
+          "name": "metadataVersion",
+          "type": "option",
+          "description": "A version identifier for the deployment",
+          "required": false,
+          "multiple": false
+        }
+      },
+      "args": {},
+      "hasCustomBuildCommand": false
+    }
+  }
+}