@nosto/nosto-cli 1.0.1

package/test/config/schema.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest"
+
+import { LogLevel, PersistentConfigSchema, RuntimeConfigSchema } from "#config/schema.ts"
+
+describe("Schema", () => {
+  describe("PersistentConfigSchema", () => {
+    it("should validate valid configuration", () => {
+      const validConfig = {
+        merchant: "test-merchant"
+      }
+
+      const result = PersistentConfigSchema.parse(validConfig)
+
+      expect(result.merchant).toBe("test-merchant")
+      expect(result.templatesEnv).toBe("main")
+      expect(result.apiUrl).toBe("https://api.nosto.com")
+      expect(result.logLevel).toBe("info")
+    })
+
+    it("should apply default values", () => {
+      const minimalConfig = {
+        merchant: "test-merchant"
+      }
+
+      const result = PersistentConfigSchema.parse(minimalConfig)
+
+      expect(result.templatesEnv).toBe("main")
+      expect(result.apiUrl).toBe("https://api.nosto.com")
+      expect(result.libraryUrl).toBe("https://d11ffvpvtnmt0d.cloudfront.net/library")
+      expect(result.logLevel).toBe("info")
+      expect(result.maxRequests).toBe(15)
+      expect(result.apiKey).toBeUndefined()
+    })
+
+    it("should validate log level enum", () => {
+      LogLevel.forEach(level => {
+        const config = {
+          merchant: "test-merchant",
+          logLevel: level
+        }
+
+        const result = PersistentConfigSchema.parse(config)
+        expect(result.logLevel).toBe(level)
+      })
+    })
+
+    it("should coerce maxRequests to number", () => {
+      const config = {
+        merchant: "test-merchant",
+        maxRequests: "20" as unknown
+      }
+
+      const result = PersistentConfigSchema.parse(config)
+      expect(result.maxRequests).toBe(20)
+      expect(typeof result.maxRequests).toBe("number")
+    })
+
+    it("should throw on invalid log level", () => {
+      const invalidConfig = {
+        merchant: "test-merchant",
+        logLevel: "invalid-level"
+      }
+
+      expect(() => PersistentConfigSchema.parse(invalidConfig)).toThrow()
+    })
+
+    it("should require merchant", () => {
+      expect(() => PersistentConfigSchema.parse({})).toThrow()
+      expect(() => PersistentConfigSchema.parse({ apiKey: "test" })).toThrow()
+    })
+  })
+
+  describe("RuntimeConfigSchema", () => {
+    it("should apply default values", () => {
+      const result = RuntimeConfigSchema.parse({})
+
+      expect(result.projectPath).toBe(".")
+      expect(result.dryRun).toBe(false)
+      expect(result.verbose).toBe(false)
+    })
+
+    it("should parse provided values", () => {
+      const config = {
+        projectPath: "/custom/path",
+        dryRun: true,
+        verbose: true
+      }
+
+      const result = RuntimeConfigSchema.parse(config)
+
+      expect(result.projectPath).toBe("/custom/path")
+      expect(result.dryRun).toBe(true)
+      expect(result.verbose).toBe(true)
+    })
+  })
+})

package/test/config/searchTemplatesConfig.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest"
+
+import { parseSearchTemplatesConfigFile } from "#config/searchTemplatesConfig.ts"
+import { NostoError } from "#errors/NostoError.ts"
+import { setupMockStarterManifest } from "#test/utils/mockStarterManifest.ts"
+
+describe("Search Templates Config", () => {
+  describe("parseSearchTemplatesConfigFile", () => {
+    it("should return legacy mode when config file does not exist", async () => {
+      const result = await parseSearchTemplatesConfigFile({ projectPath: "." })
+
+      expect(result).toEqual({
+        mode: "legacy",
+        data: {
+          onBuild: expect.any(Function),
+          onBuildWatch: expect.any(Function)
+        }
+      })
+    })
+
+    it("should return modern mode with valid config file", async () => {
+      const manifest = setupMockStarterManifest()
+      const result = await parseSearchTemplatesConfigFile({ projectPath: "." })
+
+      expect(result.mode).toBe("modern")
+      expect(result.data.onBuild).toBe(manifest.onBuild)
+      expect(result.data.onBuildWatch).toBe(manifest.onBuildWatch)
+    })
+
+    it("should throw NostoError for invalid config schema", async () => {
+      setupMockStarterManifest({
+        mockScript: {
+          // @ts-expect-error Testing invalid schema
+          invalidProp: "this should not be here"
+        }
+      })
+      await expect(parseSearchTemplatesConfigFile({ projectPath: "." })).rejects.toThrow(NostoError)
+      await expect(parseSearchTemplatesConfigFile({ projectPath: "." })).rejects.toThrow(
+        "Invalid nosto.config.ts file:"
+      )
+    })
+  })
+})

package/test/console/logger.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from "vitest"
+
+import { Logger } from "#console/logger.ts"
+
+// Undo mocking of logger in setup.ts
+vi.mock("#console/logger.ts", async importOriginal => importOriginal<typeof import("#console/logger.ts")>())
+
+describe("Logger", () => {
+  it("prints message to raw log", () => {
+    const consoleMock = vi.spyOn(console, "log").mockImplementation(() => undefined)
+    Logger.raw("Raw message")
+    expect(consoleMock).toHaveBeenCalledWith("Raw message")
+  })
+
+  it("prints raw log when log level is error", () => {
+    const consoleMock = vi.spyOn(console, "log").mockImplementation(() => undefined)
+    Logger.context.logLevel = "error"
+    Logger.raw("Raw message")
+    expect(consoleMock).toHaveBeenCalledWith("Raw message")
+  })
+
+  it("prints raw log extra payload", () => {
+    const consoleMock = vi.spyOn(console, "log").mockImplementation(() => undefined)
+    Logger.raw("Raw message", new Error("Extra payload"))
+    expect(consoleMock).toHaveBeenCalledWith(new Error("Extra payload"))
+  })
+
+  it("prints debug message when log level is debug", () => {
+    const consoleMock = vi.spyOn(console, "debug").mockImplementation(() => undefined)
+    Logger.context.logLevel = "debug"
+    Logger.debug("Debug message")
+    expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("Debug message"))
+  })
+
+  it("does not print debug message when log level is info", () => {
+    const consoleMock = vi.spyOn(console, "debug").mockImplementation(() => undefined)
+    Logger.context.logLevel = "info"
+    Logger.debug("Debug message")
+    expect(consoleMock).not.toHaveBeenCalledWith(expect.stringContaining("Debug message"))
+  })
+
+  it("prints info message when log level is info", () => {
+    const consoleMock = vi.spyOn(console, "info").mockImplementation(() => undefined)
+    Logger.context.logLevel = "info"
+    Logger.info("Info message")
+    expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("Info message"))
+  })
+
+  it("does not print info message when log level is warn", () => {
+    const consoleMock = vi.spyOn(console, "info").mockImplementation(() => undefined)
+    Logger.context.logLevel = "warn"
+    Logger.info("Info message")
+    expect(consoleMock).not.toHaveBeenCalledWith(expect.stringContaining("Info message"))
+  })
+
+  it("prints success message when log level is info", () => {
+    const consoleMock = vi.spyOn(console, "info").mockImplementation(() => undefined)
+    Logger.context.logLevel = "info"
+    Logger.success("Success message")
+    expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("Success message"))
+  })
+
+  it("does not print success message when log level is warn", () => {
+    const consoleMock = vi.spyOn(console, "log").mockImplementation(() => undefined)
+    Logger.context.logLevel = "warn"
+    Logger.success("Success message")
+    expect(consoleMock).not.toHaveBeenCalledWith(expect.stringContaining("Success message"))
+  })
+
+  it("prints warn message when log level is warn", () => {
+    const consoleMock = vi.spyOn(console, "warn").mockImplementation(() => undefined)
+    Logger.context.logLevel = "warn"
+    Logger.warn("Warn message")
+    expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("Warn message"))
+  })
+
+  it("does not print warn message when log level is error", () => {
+    const consoleMock = vi.spyOn(console, "warn").mockImplementation(() => undefined)
+    Logger.context.logLevel = "error"
+    Logger.warn("Warn message")
+    expect(consoleMock).not.toHaveBeenCalledWith(expect.stringContaining("Warn message"))
+  })
+
+  it("prints error message when log level is error", () => {
+    const consoleMock = vi.spyOn(console, "error").mockImplementation(() => undefined)
+    Logger.context.logLevel = "error"
+    Logger.error("Error message")
+    expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("Error message"))
+  })
+
+  it("prints extra payload for errors", () => {
+    const consoleMock = vi.spyOn(console, "error").mockImplementation(() => undefined)
+    Logger.error("Error message", new Error("Test error"))
+    expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("Error: Test error"))
+  })
+})

package/test/errors/withErrorHandler.test.ts

@@ -0,0 +1,64 @@
+import { HTTPError, TimeoutError } from "ky"
+import { describe, expect, it, vi } from "vitest"
+
+import { MissingConfigurationError } from "#errors/MissingConfigurationError.ts"
+import { withErrorHandler } from "#errors/withErrorHandler.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+
+describe("Error Handler", () => {
+  it("should execute function without error handling if no error occurs", async () => {
+    const mockFn = vi.fn()
+
+    await withErrorHandler(mockFn)
+
+    expect(mockFn).toHaveBeenCalled()
+  })
+
+  it("should handle MissingConfigurationError", async () => {
+    const mockFn = vi.fn(() => {
+      throw new MissingConfigurationError("Test config error")
+    })
+
+    await withErrorHandler(mockFn)
+  })
+
+  it("should handle HTTPError", async () => {
+    setupMockConfig({ verbose: true })
+    const mockFn = vi.fn(() => {
+      throw new HTTPError(
+        {
+          status: 500,
+          statusText: "Internal Server Error"
+        } as Response,
+        {
+          method: "GET",
+          url: "https://example.com/api"
+        } as Request,
+        {} as never
+      )
+    })
+
+    await withErrorHandler(mockFn)
+  })
+
+  it("should handle HTTPError", async () => {
+    setupMockConfig({ verbose: true })
+    const mockFn = vi.fn(() => {
+      throw new TimeoutError({
+        method: "GET",
+        url: "https://example.com/api"
+      } as Request)
+    })
+
+    await withErrorHandler(mockFn)
+  })
+
+  it("should rethrow unknown errors", async () => {
+    const unknownError = new Error("Unknown error")
+    const mockFn = vi.fn(() => {
+      throw unknownError
+    })
+
+    await expect(withErrorHandler(mockFn)).rejects.toThrow("Unknown error")
+  })
+})

package/test/filesystem/filesystem.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest"
+
+import { listAllFiles, writeFile } from "#filesystem/filesystem.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const mockFileSystem = setupMockFileSystem()
+
+describe("Filesystem", () => {
+  it("should write file when not in dry run mode", () => {
+    writeFile("file.txt", "content")
+    mockFileSystem.expectFile("file.txt").toContain("content")
+  })
+
+  it("should not write file when in dry run mode", () => {
+    setupMockConfig({ dryRun: true })
+
+    writeFile("file.txt", "content")
+    mockFileSystem.expectFile("file.txt").not.toExist()
+  })
+
+  it("should list all files", () => {
+    mockFileSystem.writeFile("file1.txt", "content1")
+    mockFileSystem.writeFile("file2.txt", "content2")
+    expect(listAllFiles(".")).toEqual({
+      allFiles: ["file1.txt", "file2.txt"],
+      unfilteredFileCount: 2
+    })
+  })
+
+  it("should list all files with project path", () => {
+    setupMockConfig({ projectPath: "/test/folder" })
+    mockFileSystem.writeFolder("/test/folder")
+    mockFileSystem.writeFile("/test/folder/file1.txt", "content1")
+    mockFileSystem.writeFile("/test/folder/file2.txt", "content2")
+
+    const result = listAllFiles("/test/folder")
+
+    expect(result).toEqual({
+      allFiles: ["file1.txt", "file2.txt"],
+      unfilteredFileCount: 2
+    })
+  })
+
+  it("should not include folders in the list", () => {
+    mockFileSystem.writeFile("subfolder/file1.txt", "content1")
+    mockFileSystem.writeFile("other/subfolder/file2.txt", "content2")
+    expect(listAllFiles(".")).toEqual({
+      allFiles: ["subfolder/file1.txt", "other/subfolder/file2.txt"],
+      unfilteredFileCount: 2
+    })
+  })
+})

package/test/filesystem/plugins.test.ts

@@ -0,0 +1,35 @@
+import { PluginBuild } from "esbuild"
+import { describe, it } from "vitest"
+
+import { createLoaderPlugin } from "#filesystem/esbuildPlugins.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+
+describe("createLoaderPlugin", () => {
+  it("creates loader after successful build", () => {
+    const plugin = createLoaderPlugin()
+    fs.writeFolder("build")
+
+    plugin.setup({
+      onEnd(callback: (result: { errors: unknown[] }) => void) {
+        callback({ errors: [] })
+      }
+    } as PluginBuild)
+
+    fs.expectFile("build/loader.js").toExist()
+  })
+
+  it("exits early on errors", () => {
+    const plugin = createLoaderPlugin()
+    fs.writeFolder("build")
+
+    plugin.setup({
+      onEnd(callback: (result: { errors: unknown[] }) => void) {
+        callback({ errors: [new Error("Test error")] })
+      }
+    } as PluginBuild)
+
+    fs.expectFile("build/loader.js").not.toExist()
+  })
+})

package/test/index.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it, vi } from "vitest"
+
+import * as commanderWrapper from "#commander.ts"
+
+describe("index", () => {
+  it("should pass process.argv to runCLI", async () => {
+    const spy = vi.spyOn(commanderWrapper, "runCLI")
+
+    const argv = ["/cwd", "nosto", "setup"]
+    process.argv = argv
+    await import("#/index.ts")
+
+    expect(spy).toHaveBeenCalledWith(argv)
+  })
+})

package/test/modules/search-templates/build.legacy.test.ts

@@ -0,0 +1,74 @@
+import * as esbuild from "esbuild"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+import { buildSearchTemplate } from "#modules/search-templates/build.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { mockFetchLibraryFile, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+
+vi.mock("esbuild", () => ({
+  context: vi.fn()
+}))
+
+describe("Search Templates build / legacy", () => {
+  const mockContext = {
+    rebuild: vi.fn(),
+    dispose: vi.fn(),
+    watch: vi.fn(),
+    serve: vi.fn(),
+    cancel: vi.fn()
+  }
+
+  beforeEach(() => {
+    setupMockConfig({
+      apiKey: "test-key",
+      merchant: "test-merchant",
+      projectPath: "/test-project"
+    })
+
+    vi.mocked(esbuild.context).mockResolvedValue(mockContext)
+
+    // Mock library file fetches
+    mockFetchLibraryFile(server, {
+      path: "nosto.module.js",
+      response: "// nosto.module.js content"
+    })
+    mockFetchLibraryFile(server, {
+      path: "nosto.module.js.map",
+      response: "// nosto.module.js.map content"
+    })
+    mockFetchLibraryFile(server, {
+      path: "nosto.d.ts",
+      response: "// nosto.d.ts content"
+    })
+  })
+
+  describe("buildSearchTemplate", () => {
+    it("should build templates without watch mode", async () => {
+      await buildSearchTemplate({ watch: false })
+
+      expect(mockContext.rebuild).toHaveBeenCalled()
+      expect(mockContext.dispose).toHaveBeenCalled()
+      expect(mockContext.watch).not.toHaveBeenCalled()
+    })
+
+    it("should build templates with watch mode", async () => {
+      await buildSearchTemplate({ watch: true })
+
+      expect(mockContext.watch).toHaveBeenCalled()
+      expect(mockContext.rebuild).not.toHaveBeenCalled()
+      expect(mockContext.dispose).not.toHaveBeenCalled()
+    })
+
+    it("should set up SIGINT handler in watch mode", async () => {
+      const processOnSpy = vi.spyOn(process, "on").mockImplementation(() => process)
+
+      await buildSearchTemplate({ watch: true })
+
+      expect(processOnSpy).toHaveBeenCalledWith("SIGINT", expect.any(Function))
+
+      processOnSpy.mockRestore()
+    })
+  })
+})

package/test/modules/search-templates/build.modern.test.ts

@@ -0,0 +1,33 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+import { parseSearchTemplatesConfigFile } from "#config/searchTemplatesConfig.ts"
+import { buildSearchTemplate } from "#modules/search-templates/build.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockStarterManifest } from "#test/utils/mockStarterManifest.ts"
+
+describe("Search Templates build / modern", () => {
+  beforeEach(() => {
+    setupMockStarterManifest()
+  })
+  it("should build templates without watch mode", async () => {
+    const manifest = setupMockStarterManifest({
+      mockScript: { onBuild: vi.fn() }
+    })
+    setupMockConfig({
+      searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })
+    })
+    await buildSearchTemplate({ watch: false })
+    expect(manifest.onBuild).toHaveBeenCalled()
+  })
+
+  it("should build templates with watch mode", async () => {
+    const manifest = setupMockStarterManifest({
+      mockScript: { onBuildWatch: vi.fn() }
+    })
+    setupMockConfig({
+      searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })
+    })
+    await buildSearchTemplate({ watch: true })
+    expect(manifest.onBuildWatch).toHaveBeenCalled()
+  })
+})

package/test/modules/search-templates/dev.legacy.test.ts

@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+import * as esbuild from "#filesystem/esbuild.ts"
+import { searchTemplateDevMode } from "#modules/search-templates/dev.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+import { mockFetchLibraryFile, setupMockServer } from "#test/utils/mockServer.ts"
+
+const fs = setupMockFileSystem()
+const server = setupMockServer()
+const mockConsole = setupMockConsole()
+
+describe("Search Templates dev mode / legacy", () => {
+  const mockContext = {
+    watch: vi.fn(),
+    dispose: vi.fn()
+  }
+
+  beforeEach(() => {
+    vi.spyOn(esbuild, "getBuildContext").mockReturnValue(
+      mockContext as unknown as ReturnType<typeof esbuild.getBuildContext>
+    )
+
+    setupMockConfig({
+      libraryUrl: "https://library.nosto.com"
+    })
+    mockFetchLibraryFile(server, {
+      path: "nosto.module.js",
+      response: "// nosto.module.js content"
+    })
+    mockFetchLibraryFile(server, {
+      path: "nosto.module.js.map",
+      response: "// nosto.module.js.map content"
+    })
+    mockFetchLibraryFile(server, {
+      path: "nosto.d.ts",
+      response: "// nosto.d.ts content"
+    })
+  })
+
+  it("should start watching when confirmed", async () => {
+    const getBuildContext = vi.spyOn(esbuild, "getBuildContext")
+
+    await searchTemplateDevMode()
+
+    expect(getBuildContext).toHaveBeenCalledWith({ plugins: [expect.objectContaining({ name: "push-on-rebuild" })] })
+    expect(mockContext.watch).toHaveBeenCalled()
+  })
+
+  it("should skip confirmation when flag is set", async () => {
+    await searchTemplateDevMode()
+
+    mockConsole.expect.user.not.toHaveBeenPrompted()
+    expect(mockContext.watch).toHaveBeenCalled()
+  })
+
+  it("should set up SIGINT handler", async () => {
+    const processOnSpy = vi.spyOn(process, "on").mockImplementation(() => process)
+
+    await searchTemplateDevMode()
+
+    expect(processOnSpy).toHaveBeenCalledWith("SIGINT", expect.any(Function))
+
+    processOnSpy.mockRestore()
+  })
+
+  it("should have pulled the library", async () => {
+    await searchTemplateDevMode()
+
+    fs.expectFile(".nostocache/library/nosto.module.js").toContain('"// nosto.module.js content"')
+    fs.expectFile(".nostocache/library/nosto.module.js.map").toContain('"// nosto.module.js.map content"')
+    fs.expectFile(".nostocache/library/nosto.d.ts").toContain('"// nosto.d.ts content"')
+  })
+})

package/test/modules/search-templates/dev.modern.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it, vi } from "vitest"
+
+import { OnStartDevProps } from "#config/schema.ts"
+import { parseSearchTemplatesConfigFile } from "#config/searchTemplatesConfig.ts"
+import { searchTemplateDevMode } from "#modules/search-templates/dev.ts"
+import * as pushCommandModule from "#modules/search-templates/push.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockStarterManifest } from "#test/utils/mockStarterManifest.ts"
+
+describe("Search Templates dev mode / modern", () => {
+  it("should build templates with watch mode", async () => {
+    const manifest = setupMockStarterManifest({
+      mockScript: {
+        onBuildWatch: vi.fn()
+      }
+    })
+    setupMockConfig({
+      searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })
+    })
+
+    await searchTemplateDevMode()
+    expect(manifest.onBuildWatch).toHaveBeenCalled()
+  })
+
+  it("runs the callback after build", async () => {
+    const manifest = setupMockStarterManifest({
+      mockScript: {
+        onBuildWatch: vi.fn().mockImplementation(async (args: OnStartDevProps) => {
+          args.onAfterBuild()
+        })
+      }
+    })
+    setupMockConfig({
+      searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })
+    })
+
+    vi.spyOn(pushCommandModule, "pushSearchTemplate").mockImplementation(vi.fn())
+
+    await searchTemplateDevMode()
+
+    expect(manifest.onBuildWatch).toHaveBeenCalled()
+    expect(pushCommandModule.pushSearchTemplate).toHaveBeenCalledWith({ paths: ["build"], force: false })
+  })
+})