@nosto/nosto-cli 1.0.1

package/src/utils/withSafeEnvironment.ts

@@ -0,0 +1,22 @@
+import { loadConfig, type LoadConfigProps } from "#config/config.ts"
+import { withErrorHandler } from "#errors/withErrorHandler.ts"
+import { assertGitRepo } from "#filesystem/asserts/assertGitRepo.ts"
+import { assertNostoTemplate } from "#filesystem/asserts/assertNostoTemplate.ts"
+
+type Props = LoadConfigProps & {
+  skipSanityCheck?: boolean
+}
+
+export async function withSafeEnvironment(
+  { skipSanityCheck, ...props }: Props,
+  fn: () => void | Promise<void>
+): Promise<void> {
+  await withErrorHandler(async () => {
+    await loadConfig(props)
+    if (!skipSanityCheck) {
+      assertNostoTemplate()
+    }
+    assertGitRepo()
+    await fn()
+  })
+}

package/test/api/fetchSourceFile.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest"
+
+import { fetchSourceFileIfExists } from "#api/source/fetchSourceFile.js"
+import { mockFetchSourceFile, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+
+describe("fetchSourceFileIfExists", () => {
+  it("fetches the file if exists", async () => {
+    mockFetchSourceFile(server, { path: "test.txt", response: "file content" })
+
+    const file = await fetchSourceFileIfExists("test.txt")
+
+    expect(file).toBe('"file content"')
+  })
+
+  it("returns null if server returns 404", async () => {
+    mockFetchSourceFile(server, { path: "test.txt", error: { status: 404, message: "Not Found" } })
+
+    const file = await fetchSourceFileIfExists("test.txt")
+
+    expect(file).toBe(null)
+  })
+
+  it("throws an error for status code 500", async () => {
+    mockFetchSourceFile(server, { path: "test.txt", error: { status: 500, message: "Server Error" } })
+
+    await expect(fetchSourceFileIfExists("test.txt")).rejects.toThrow()
+  })
+})

package/test/api/putSourceFile.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest"
+
+import { putSourceFile } from "#api/source/putSourceFile.js"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { mockFetchSourceFile, mockPutSourceFile, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+
+describe("putSourceFile", () => {
+  it("sends the file content", async () => {
+    const endpoint = mockPutSourceFile(server, { path: "test.txt" })
+
+    await putSourceFile("test.txt", "file content")
+
+    const invocations = endpoint.invocations
+    expect(endpoint.invocations.length).toBeGreaterThan(0)
+    expect(invocations.some(invocation => invocation === "file content")).toBe(true)
+  })
+
+  it("throws an error for status code 404", async () => {
+    mockFetchSourceFile(server, { path: "test.txt", error: { status: 404, message: "Not Found" } })
+
+    await expect(putSourceFile("test.txt", "file content")).rejects.toThrow()
+  })
+
+  it("returns early for a dry run", async () => {
+    const endpoint = mockPutSourceFile(server, { path: "test.txt" })
+    setupMockConfig({ dryRun: true })
+
+    await putSourceFile("test.txt", "file content")
+
+    expect(endpoint.invocations.length).toBe(0)
+  })
+})

package/test/api/retry.test.ts

@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+import { fetchWithRetry } from "#api/retry.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+
+const terminal = setupMockConsole()
+
+describe("API Retry", () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  describe("fetchWithRetry", () => {
+    it("should return result on first successful attempt", async () => {
+      const mockApiFunction = vi.fn().mockResolvedValue("success")
+
+      const result = await fetchWithRetry(mockApiFunction, "test-file.txt")
+
+      expect(result).toBe("success")
+      expect(mockApiFunction).toHaveBeenCalledTimes(1)
+      expect(mockApiFunction).toHaveBeenCalledWith("test-file.txt")
+    })
+
+    it("should retry on failure and eventually succeed", async () => {
+      const mockApiFunction = vi
+        .fn()
+        .mockRejectedValueOnce(new Error("First failure"))
+        .mockRejectedValueOnce(new Error("Second failure"))
+        .mockResolvedValue("success")
+
+      const retryPromise = fetchWithRetry(mockApiFunction, "test-file.txt")
+
+      // Fast forward through the retry delays
+      await vi.runAllTimersAsync()
+
+      const result = await retryPromise
+
+      expect(result).toBe("success")
+      expect(mockApiFunction).toHaveBeenCalledTimes(3)
+    })
+
+    it("should throw error after max retries exceeded", async () => {
+      const mockApiFunction = vi.fn().mockRejectedValue(new Error("Persistent failure"))
+
+      const retryPromise = fetchWithRetry(mockApiFunction, "test-file.txt")
+
+      // Fast forward through all retry delays
+      const assertion = expect(retryPromise).rejects.toThrow(
+        "Failed to fetch test-file.txt after 3 retries: Persistent failure"
+      )
+      await vi.runAllTimersAsync()
+
+      await assertion
+
+      expect(mockApiFunction).toHaveBeenCalledTimes(4) // Initial + 3 retries
+    })
+
+    it("should log warnings during retries", async () => {
+      const mockApiFunction = vi.fn().mockRejectedValueOnce(new Error("Temporary failure")).mockResolvedValue("success")
+
+      const retryPromise = fetchWithRetry(mockApiFunction, "test-file.txt")
+
+      // Fast forward through the retry delay
+      await vi.runAllTimersAsync()
+
+      await retryPromise
+
+      expect(terminal.getSpy("warn")).toHaveBeenCalledWith(
+        expect.stringContaining("Failed to fetch test-file.txt: Retrying in 1000ms (attempt 1/3)")
+      )
+    })
+
+    it("should log error on final failure", async () => {
+      const mockApiFunction = vi.fn().mockRejectedValue(new Error("Final error"))
+
+      const retryPromise = fetchWithRetry(mockApiFunction, "test-file.txt")
+
+      const assertion = expect(retryPromise).rejects.toThrow()
+      await vi.runAllTimersAsync()
+
+      await assertion
+
+      expect(terminal.getSpy("error")).toHaveBeenCalledWith(expect.stringContaining("test-file.txt: Final error"))
+    })
+
+    it("should handle non-Error objects", async () => {
+      const mockApiFunction = vi.fn().mockRejectedValue("String error")
+
+      const retryPromise = fetchWithRetry(mockApiFunction, "test-file.txt")
+
+      const assertion = expect(retryPromise).rejects.toThrow(
+        "Failed to fetch test-file.txt after 3 retries: String error"
+      )
+      await vi.runAllTimersAsync()
+      await assertion
+    })
+  })
+})

package/test/api/utils.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest"
+
+import { cleanUrl } from "#api/utils.ts"
+
+describe("API Utils", () => {
+  describe("cleanUrl", () => {
+    it("should remove leading slash", () => {
+      expect(cleanUrl("/path/to/resource")).toBe("path/to/resource")
+    })
+
+    it("should remove trailing slash", () => {
+      expect(cleanUrl("path/to/resource/")).toBe("path/to/resource")
+    })
+
+    it("should remove both leading and trailing slashes", () => {
+      expect(cleanUrl("/path/to/resource/")).toBe("path/to/resource")
+    })
+
+    it("should not modify URL without slashes", () => {
+      expect(cleanUrl("path/to/resource")).toBe("path/to/resource")
+    })
+
+    it("should handle empty string", () => {
+      expect(cleanUrl("")).toBe("")
+    })
+  })
+})

package/test/commander.test.ts

@@ -0,0 +1,271 @@
+import { beforeEach, describe, expect, it, MockInstance, vi } from "vitest"
+
+import { MissingConfigurationError } from "#errors/MissingConfigurationError.ts"
+import * as build from "#modules/search-templates/build.ts"
+import * as dev from "#modules/search-templates/dev.ts"
+import * as pull from "#modules/search-templates/pull.ts"
+import * as push from "#modules/search-templates/push.ts"
+import * as setup from "#modules/setup.ts"
+import * as status from "#modules/status.ts"
+
+import { setupMockCommander } from "./utils/mockCommander.ts"
+import { setupMockFileSystem } from "./utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+const commander = setupMockCommander()
+
+let setupSpy: MockInstance
+let statusSpy: MockInstance
+let buildSpy: MockInstance
+let pullSpy: MockInstance
+let pushSpy: MockInstance
+let devSpy: MockInstance
+
+describe("commander", () => {
+  // Make sure the actual functions are never called
+  beforeEach(() => {
+    setupSpy = vi.spyOn(setup, "printSetupHelp").mockImplementation(() => Promise.resolve())
+    statusSpy = vi.spyOn(status, "printStatus").mockImplementation(() => Promise.resolve())
+    buildSpy = vi.spyOn(build, "buildSearchTemplate").mockImplementation(() => Promise.resolve())
+    pullSpy = vi.spyOn(pull, "pullSearchTemplate").mockImplementation(() => Promise.resolve())
+    pushSpy = vi.spyOn(push, "pushSearchTemplate").mockImplementation(() => Promise.resolve())
+    devSpy = vi.spyOn(dev, "searchTemplateDevMode").mockImplementation(() => Promise.resolve())
+  })
+
+  describe("nosto setup", () => {
+    it("should call the function", async () => {
+      await commander.run("nosto setup")
+      expect(setupSpy).toHaveBeenCalledWith(".", {})
+    })
+
+    it("should call the function with project path", async () => {
+      await commander.run("nosto setup /path/to/project")
+      expect(setupSpy).toHaveBeenCalledWith("/path/to/project", {})
+    })
+
+    it("should handle MissingConfigurationError", async () => {
+      vi.spyOn(setup, "printSetupHelp").mockImplementation(() => {
+        throw new MissingConfigurationError("Missing configuration")
+      })
+
+      await commander.expect("nosto setup").toResolve()
+    })
+
+    it("should rethrow other errors", async () => {
+      vi.spyOn(setup, "printSetupHelp").mockImplementation(() => {
+        throw new Error("Unknown error")
+      })
+
+      await commander.expect("nosto setup").toThrow()
+    })
+
+    it("does not call other modules", async () => {
+      await commander.run("nosto setup")
+      expect(statusSpy).not.toHaveBeenCalled()
+      expect(buildSpy).not.toHaveBeenCalled()
+      expect(pullSpy).not.toHaveBeenCalled()
+      expect(pushSpy).not.toHaveBeenCalled()
+      expect(devSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe("nosto status", () => {
+    it("should call the function", async () => {
+      await commander.run("nosto status")
+      expect(statusSpy).toHaveBeenCalledWith(".")
+    })
+
+    it("should call the function with project path", async () => {
+      await commander.run("nosto status /path/to/project")
+      expect(statusSpy).toHaveBeenCalledWith("/path/to/project")
+    })
+
+    it("should handle MissingConfigurationError", async () => {
+      vi.spyOn(status, "printStatus").mockImplementation(() => {
+        throw new MissingConfigurationError("Missing configuration")
+      })
+
+      await commander.expect("nosto status").toResolve()
+    })
+
+    it("should rethrow other errors", async () => {
+      vi.spyOn(status, "printStatus").mockImplementation(() => {
+        throw new Error("Unknown error")
+      })
+
+      await commander.expect("nosto status").toThrow()
+    })
+
+    it("does not call other modules", async () => {
+      await commander.run("nosto status")
+      expect(setupSpy).not.toHaveBeenCalled()
+      expect(buildSpy).not.toHaveBeenCalled()
+      expect(pullSpy).not.toHaveBeenCalled()
+      expect(pushSpy).not.toHaveBeenCalled()
+      expect(devSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe("nosto search-templates build", () => {
+    it("should fail sanity check", async () => {
+      await commander.run("nosto st build")
+      expect(buildSpy).not.toHaveBeenCalled()
+    })
+
+    describe("with valid environment", () => {
+      beforeEach(() => {
+        fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+        fs.writeFile("index.js", "@nosto/preact")
+      })
+
+      it("should call the function", async () => {
+        await commander.run("nosto st build")
+        expect(buildSpy).toHaveBeenCalledWith({ watch: false })
+      })
+
+      it("should rethrow errors", async () => {
+        vi.spyOn(build, "buildSearchTemplate").mockImplementation(() => {
+          throw new Error("Unknown error")
+        })
+
+        await commander.expect("nosto st build").toThrow()
+      })
+
+      it("does not call other modules", async () => {
+        await commander.run("nosto st build")
+        expect(setupSpy).not.toHaveBeenCalled()
+        expect(statusSpy).not.toHaveBeenCalled()
+        expect(pullSpy).not.toHaveBeenCalled()
+        expect(pushSpy).not.toHaveBeenCalled()
+        expect(devSpy).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe("nosto search-templates pull", () => {
+    it("should pull even without files present", async () => {
+      await commander.run("nosto st pull")
+      expect(pullSpy).toHaveBeenCalled()
+    })
+
+    describe("with valid environment", () => {
+      beforeEach(() => {
+        fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+        fs.writeFile("index.js", "@nosto/preact")
+      })
+
+      it("should call the function", async () => {
+        await commander.run("nosto st pull")
+        expect(pullSpy).toHaveBeenCalledWith({ force: false, paths: [] })
+      })
+
+      it("should call the function with short parameters", async () => {
+        await commander.run("nosto st pull -f -p build index.js")
+        expect(pullSpy).toHaveBeenCalledWith({ force: true, paths: ["build", "index.js"] })
+      })
+
+      it("should call the function with full parameters", async () => {
+        await commander.run("nosto st pull --force --paths build index.js")
+        expect(pullSpy).toHaveBeenCalledWith({ force: true, paths: ["build", "index.js"] })
+      })
+
+      it("should rethrow errors", async () => {
+        vi.spyOn(pull, "pullSearchTemplate").mockImplementation(() => {
+          throw new Error("Unknown error")
+        })
+
+        await commander.expect("nosto st pull").toThrow()
+      })
+
+      it("does not call other modules", async () => {
+        await commander.run("nosto st pull")
+        expect(setupSpy).not.toHaveBeenCalled()
+        expect(statusSpy).not.toHaveBeenCalled()
+        expect(buildSpy).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe("nosto search-templates push", () => {
+    it("should fail sanity check", async () => {
+      await commander.run("nosto st push")
+      expect(pushSpy).not.toHaveBeenCalled()
+    })
+
+    describe("with valid environment", () => {
+      beforeEach(() => {
+        fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+        fs.writeFile("index.js", "@nosto/preact")
+      })
+
+      it("should call the build and push functions", async () => {
+        await commander.run("nosto st push")
+        expect(buildSpy).toHaveBeenCalledWith({ watch: false })
+        expect(pushSpy).toHaveBeenCalledWith({ force: false, paths: [] })
+      })
+
+      it("should call the function with short parameters", async () => {
+        await commander.run("nosto st push -f -p build index.js")
+        expect(buildSpy).toHaveBeenCalledWith({ watch: false })
+        expect(pushSpy).toHaveBeenCalledWith({ force: true, paths: ["build", "index.js"] })
+      })
+
+      it("should call the function with full parameters", async () => {
+        await commander.run("nosto st push --force --paths build index.js")
+        expect(buildSpy).toHaveBeenCalledWith({ watch: false })
+        expect(pushSpy).toHaveBeenCalledWith({ force: true, paths: ["build", "index.js"] })
+      })
+
+      it("should rethrow errors", async () => {
+        vi.spyOn(push, "pushSearchTemplate").mockImplementation(() => {
+          throw new Error("Unknown error")
+        })
+
+        await commander.expect("nosto st push").toThrow()
+      })
+
+      it("does not call other modules", async () => {
+        await commander.run("nosto st push")
+        expect(setupSpy).not.toHaveBeenCalled()
+        expect(statusSpy).not.toHaveBeenCalled()
+        expect(pullSpy).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe("nosto search-templates dev", () => {
+    it("should fail sanity check", async () => {
+      await commander.run("nosto st dev")
+      expect(devSpy).not.toHaveBeenCalled()
+    })
+
+    describe("with valid environment", () => {
+      beforeEach(() => {
+        fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+        fs.writeFile("index.js", "@nosto/preact")
+      })
+
+      it("should call the function", async () => {
+        await commander.run("nosto st dev")
+        expect(devSpy).toHaveBeenCalled()
+      })
+
+      it("should rethrow errors", async () => {
+        vi.spyOn(dev, "searchTemplateDevMode").mockImplementation(() => {
+          throw new Error("Unknown error")
+        })
+
+        await commander.expect("nosto st dev").toThrow()
+      })
+
+      it("does not call other modules", async () => {
+        await commander.run("nosto st dev")
+        expect(setupSpy).not.toHaveBeenCalled()
+        expect(statusSpy).not.toHaveBeenCalled()
+        expect(buildSpy).not.toHaveBeenCalled()
+        expect(pullSpy).not.toHaveBeenCalled()
+        expect(pushSpy).not.toHaveBeenCalled()
+      })
+    })
+  })
+})

package/test/config/envConfig.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+
+import { EnvVariables, getEnvConfig } from "#config/envConfig.ts"
+
+describe("Env Config", () => {
+  const originalEnv = process.env
+
+  beforeEach(() => {
+    process.env = {}
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+  })
+
+  describe("getEnvConfig", () => {
+    it("should return empty config when no environment variables are set", () => {
+      const result = getEnvConfig()
+      expect(result).toEqual({})
+    })
+
+    it("should parse environment variables correctly", () => {
+      process.env[EnvVariables.apiKey] = "env-api-key"
+      process.env[EnvVariables.merchant] = "env-merchant"
+      process.env[EnvVariables.logLevel] = "debug"
+      process.env[EnvVariables.maxRequests] = "25"
+
+      const result = getEnvConfig()
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          apiKey: "env-api-key",
+          merchant: "env-merchant",
+          logLevel: "debug",
+          maxRequests: 25 // Coerced to number by schema
+        })
+      )
+    })
+
+    it("should handle all possible environment variables", () => {
+      process.env[EnvVariables.apiKey] = "another-key"
+      process.env[EnvVariables.merchant] = "another-merchant"
+      process.env[EnvVariables.templatesEnv] = "staging"
+      process.env[EnvVariables.apiUrl] = "https://custom-api.com"
+      process.env[EnvVariables.libraryUrl] = "https://custom-library.com"
+      process.env[EnvVariables.logLevel] = "warn"
+      process.env[EnvVariables.maxRequests] = "50"
+
+      const result = getEnvConfig()
+
+      expect(result).toEqual({
+        apiKey: "another-key",
+        merchant: "another-merchant",
+        templatesEnv: "staging",
+        apiUrl: "https://custom-api.com",
+        libraryUrl: "https://custom-library.com",
+        logLevel: "warn",
+        maxRequests: 50 // Coerced to number by schema
+      })
+    })
+  })
+})

package/test/config/fileConfig.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest"
+
+import { parseConfigFile } from "#config/fileConfig.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+
+describe("File Config", () => {
+  describe("parseConfigFile", () => {
+    it("should return empty object when config file does not exist", () => {
+      const result = parseConfigFile({ projectPath: "." })
+      expect(result).toEqual({})
+    })
+
+    it("should parse valid JSON config file", () => {
+      const mockConfig = {
+        apiKey: "another-key",
+        merchant: "another-merchant",
+        logLevel: "debug",
+        apiUrl: "https://api.nosto.com"
+      }
+
+      fs.writeFile(".nosto.json", JSON.stringify(mockConfig))
+
+      const result = parseConfigFile({ projectPath: "." })
+
+      expect(result).toEqual({
+        apiKey: "another-key",
+        apiUrl: "https://api.nosto.com",
+        libraryUrl: "https://d11ffvpvtnmt0d.cloudfront.net/library",
+        logLevel: "debug",
+        maxRequests: 15,
+        merchant: "another-merchant",
+        templatesEnv: "main"
+      })
+    })
+
+    it("should throw error for invalid JSON", () => {
+      fs.writeFile(".nosto.json", "invalid json")
+
+      expect(() => parseConfigFile({ projectPath: "." })).toThrow("Invalid JSON in configuration file")
+    })
+
+    it("should throw error for invalid config schema", () => {
+      const invalidConfig = {
+        apiKey: "test-key",
+        logLevel: "invalid-level"
+      }
+
+      fs.writeFile(".nosto.json", JSON.stringify(invalidConfig))
+
+      expect(() => parseConfigFile({ projectPath: "." })).toThrow("Invalid configuration file")
+    })
+
+    it("should rethrow other errors", () => {
+      fs.writeFolder(".nosto.json")
+
+      expect(() => parseConfigFile({ projectPath: "." })).toThrow(
+        "EISDIR: illegal operation on a directory, open '/.nosto.json'"
+      )
+    })
+  })
+})