@nosto/nosto-cli 1.0.3 → 1.1.0

package/.github/copilot-instructions.md

@@ -74,7 +74,7 @@ tsx /path/to/nosto-cli/src/index.ts st --help
 tsx /path/to/nosto-cli/src/index.ts st build --help
 
 # Test dry run (will attempt API connection and fail - this is expected)
-mkdir -p src && echo 'console.log("test");' > src/test.js
+mkdir -p src && echo 'console.info("test");' > src/test.js
 tsx /path/to/nosto-cli/src/index.ts st build --dry-run
 ```
 
@@ -220,7 +220,7 @@ const server = setupMockServer()
 // Usage
 mockFetchSourceFile(server, {
   path: "index.js",
-  response: "console.log('test')"
+  response: "console.info('test')"
 })
 ```
 

package/.github/dependabot.yml

@@ -6,4 +6,15 @@ updates:
       interval: "weekly"
     commit-message:
       prefix: "deps"
-    open-pull-requests-limit: 10
+    open-pull-requests-limit: 10
+    groups:
+      eslint:
+        patterns:
+          - "@eslint/*"
+          - "eslint"
+          - "eslint-*"
+          - "typescript-eslint"
+      vitest:
+        patterns:
+          - "@vitest/*"
+          - "vitest"

package/README.md

@@ -6,7 +6,7 @@ A command-line interface to interact with Nosto's backend systems. Primarily aim
 
 # About Nosto
 
-If you are unfamiliar with Nosto as a company, you are welcome to visit our homepage at [https://nosto.com/](https://www.nosto.com/).
+If you are unfamiliar with Nosto as a company, you are welcome to visit our homepage at [https://www.nosto.com](https://www.nosto.com/).
 
 If you wish to know more about our tech stack, we publish extensive documentation known as the [Techdocs](https://docs.nosto.com/techdocs).
 
@@ -14,7 +14,7 @@ If you wish to know more about our tech stack, we publish extensive documentatio
 
 Nosto CLI aims to be as user-friendly as CLI tools get. You should be able to get up and running by utilizing the built-in `help` and `setup` commands, but a quick-start guide is also provided here.
 
-To start with, you may create an empty folder for your folder; or you may clone your git repository to work with.
+To start with, you may create an empty folder for your project; or you may clone your git repository to work with.
 
 ```bash
 # Install the CLI tool:
@@ -155,4 +155,4 @@ Running `nosto st push` after `nosto st dev` without changing any files will sto
 
 ## Contributions
 
-We welcome both internal and external contributions to this project! Feel free to request bugfixes, open issues or PRs for review. Nosto is actively maintaining this project, and we will process your contributions as soon as possible.
+We welcome both internal and external contributions to this project! Feel free to request bugfixes, open issues or PRs for review. Nosto is actively maintaining this project, and we will process your contributions as soon as possible.

package/eslint.config.js

@@ -27,9 +27,19 @@ export default defineConfig([
     },
     rules: {
       "unused-imports/no-unused-imports": "error",
+      "unused-imports/no-unused-vars": [
+        "warn",
+        {
+          vars: "all",
+          varsIgnorePattern: "^_",
+          args: "after-used",
+          argsIgnorePattern: "^_"
+        }
+      ],
       "simple-import-sort/imports": "error",
       "simple-import-sort/exports": "error",
-      "no-restricted-imports": ["error", "node:test"]
+      "no-restricted-imports": ["error", "node:test"],
+      "@typescript-eslint/no-unused-vars": "off"
     }
   },
   eslintPluginPrettierRecommended

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosto/nosto-cli",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "main": "./src/index.ts",
   "bin": {
     "nosto": "./src/bootstrap.mjs"
@@ -31,7 +31,7 @@
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.1",
-    "esbuild": "^0.25.10",
+    "esbuild": "^0.27.0",
     "ignore": "^7.0.5",
     "ky": "^1.11.0",
     "open": "^10.2.0",
@@ -43,9 +43,9 @@
     "@commitlint/cli": "^20.1.0",
     "@commitlint/config-conventional": "^20.0.0",
     "@eslint/js": "^9.37.0",
-    "@types/node": "^24.7.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
+    "@types/node": "^24.7.2",
+    "@vitest/coverage-v8": "^4.0.6",
+    "@vitest/ui": "^4.0.6",
     "eslint": "^9.37.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
@@ -53,10 +53,10 @@
     "eslint-plugin-unused-imports": "^4.2.0",
     "husky": "^9.1.7",
     "memfs": "^4.48.1",
-    "msw": "^2.11.3",
+    "msw": "^2.11.5",
     "prettier": "^3.6.2",
-    "typescript-eslint": "^8.45.0",
-    "vitest": "^3.2.4"
+    "typescript-eslint": "^8.46.0",
+    "vitest": "^4.0.6"
   },
   "publishConfig": {
     "access": "public"

package/src/api/retry.ts

@@ -2,27 +2,43 @@ import chalk from "chalk"
 
 import { Logger } from "#console/logger.ts"
 
+import { putSourceFile } from "./source/putSourceFile.ts"
+
 const MAX_RETRIES = 3
 const INITIAL_RETRY_DELAY = 1000 // 1 second
 
-export async function fetchWithRetry(
-  apiFunction: (filePath: string) => Promise<string>,
+async function executeWithRetry<T>(
+  operation: () => Promise<T>,
   filePath: string,
+  operationType: "fetch" | "push",
   retryCount = 0
-): Promise<string> {
+): Promise<T> {
   try {
-    return await apiFunction(filePath)
+    return await operation()
   } catch (error: unknown) {
     if (retryCount >= MAX_RETRIES) {
       const errorMessage = error instanceof Error ? error.message : String(error)
-      Logger.error(`${chalk.red("✗")} ${chalk.cyan(filePath)}: ${errorMessage}`)
-      throw new Error(`Failed to fetch ${filePath} after ${MAX_RETRIES} retries: ${errorMessage}`)
+      if (operationType === "fetch") {
+        Logger.error(`${chalk.red("✗")} ${chalk.cyan(filePath)}: ${errorMessage}`)
+      }
+      throw new Error(`Failed to ${operationType} ${filePath} after ${MAX_RETRIES} retries: ${errorMessage}`)
     }
     const delay = INITIAL_RETRY_DELAY * Math.pow(2, retryCount)
     Logger.warn(
-      `${chalk.yellow("⟳")} Failed to fetch ${chalk.cyan(filePath)}: Retrying in ${delay}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`
+      `${chalk.yellow("⟳")} Failed to ${operationType} ${chalk.cyan(filePath)}: Retrying in ${delay}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`
     )
     await new Promise(resolve => setTimeout(resolve, delay))
-    return fetchWithRetry(apiFunction, filePath, retryCount + 1)
+    return executeWithRetry(operation, filePath, operationType, retryCount + 1)
   }
 }
+
+export async function fetchWithRetry(
+  apiFunction: (filePath: string) => Promise<string>,
+  filePath: string
+): Promise<string> {
+  return executeWithRetry(() => apiFunction(filePath), filePath, "fetch")
+}
+
+export async function putWithRetry(filePath: string, content: string): Promise<void> {
+  return executeWithRetry(() => putSourceFile(filePath, content), filePath, "push")
+}

package/src/config/authConfig.ts

@@ -1,13 +1,13 @@
 import fs from "fs"
-import os from "os"
 import path from "path"
 import z from "zod"
 
 import { MissingConfigurationError } from "#errors/MissingConfigurationError.ts"
+import { HomeDirectory } from "#filesystem/homeDirectory.ts"
 
 import { type AuthConfig, AuthConfigSchema } from "./schema.ts"
 
-export const AuthConfigFilePath = path.join(os.homedir(), ".nosto", ".auth.json")
+export const AuthConfigFilePath = path.join(HomeDirectory, ".nosto", ".auth.json")
 
 export function authFileExists() {
   return fs.existsSync(AuthConfigFilePath)

package/src/config/config.ts

@@ -17,7 +17,7 @@ import {
 import { parseSearchTemplatesConfigFile } from "./searchTemplatesConfig.ts"
 
 let isConfigLoaded = false
-let cachedConfig: Config = {
+const defaultCachedConfig: Config = {
   ...getDefaultConfig(),
   auth: AuthConfigSchema.parse({
     user: "",
@@ -30,6 +30,7 @@ let cachedConfig: Config = {
   },
   ...RuntimeConfigSchema.parse({})
 }
+let cachedConfig = defaultCachedConfig
 
 export type LoadConfigProps = {
   projectPath: string
@@ -107,3 +108,8 @@ export function getDefaultConfig() {
     merchant: ""
   })
 }
+
+export function clearCachedConfig() {
+  isConfigLoaded = false
+  cachedConfig = defaultCachedConfig
+}

package/src/errors/InvalidLoginResponseError.ts

@@ -9,6 +9,6 @@ export class InvalidLoginResponseError extends NostoError {
   }
 
   handle() {
-    Logger.error(this.message)
+    Logger.error(`Received malformed login response from server. This is probably a bug on our side.`, this)
   }
 }

package/src/errors/withErrorHandler.ts

@@ -4,34 +4,30 @@ import { HTTPError, TimeoutError } from "ky"
 import { getCachedConfig } from "#config/config.ts"
 import { Logger } from "#console/logger.ts"
 
-import { InvalidLoginResponseError } from "./InvalidLoginResponseError.ts"
 import { NostoError } from "./NostoError.ts"
 
 export async function withErrorHandler(fn: () => void | Promise<void>): Promise<void> {
+  function printStack(error: Error) {
+    const config = getCachedConfig()
+    if (config.verbose) {
+      Logger.raw(chalk.red(prettyPrintStack(error.stack)))
+    } else {
+      Logger.info(chalk.gray("Rerun with --verbose to see details"))
+    }
+  }
   try {
     await fn()
   } catch (error) {
     if (error instanceof HTTPError) {
-      const config = getCachedConfig()
       Logger.error(`HTTP Request failed:`)
       Logger.error(`- ${error.response.status} ${error.response.statusText}`)
       Logger.error(`- ${error.request.method} ${error.request.url}`)
-      if (config.verbose) {
-        Logger.raw(chalk.red(prettyPrintStack(error.stack)))
-      }
-      if (!config.verbose) {
-        Logger.info(chalk.gray("Rerun with --verbose to see details"))
-      }
+      printStack(error)
     } else if (error instanceof TimeoutError) {
-      const config = getCachedConfig()
       Logger.error(`HTTP Request timed out:`)
       Logger.error(`- Server did not respond after 10 seconds`)
       Logger.error(`- ${error.request.method} ${error.request.url}`)
-      if (config.verbose) {
-        Logger.raw(chalk.red(prettyPrintStack(error.stack)))
-      }
-    } else if (error instanceof InvalidLoginResponseError) {
-      Logger.error(`Received malformed login response from server. This is probably a bug on our side.`, error)
+      printStack(error)
     } else if (error instanceof NostoError) {
       error.handle()
     } else {

package/src/filesystem/homeDirectory.ts

@@ -0,0 +1,3 @@
+import os from "os"
+
+export const HomeDirectory = import.meta.env.MODE === "test" ? "/vitest/home" : os.homedir()

package/src/filesystem/processInBatches.ts

@@ -27,6 +27,7 @@ export async function processInBatches({ files, logIcon, processElement }: Props
       } catch (error: unknown) {
         const errorMessage = error instanceof Error ? error.message : String(error)
         Logger.error(`${chalk.red("✗")} ${chalk.cyan(file)}: ${errorMessage}`)
+        throw error
       }
     })
     const results = await Promise.allSettled(batchPromises)

package/src/modules/login.ts

@@ -29,6 +29,9 @@ export async function loginToPlaycart() {
 
   Logger.info("Awaiting response from the browser...")
   const response = await server.responseData
+  if ("error" in response) {
+    throw new InvalidLoginResponseError(response.error)
+  }
   writeFile(AuthConfigFilePath, JSON.stringify(response, null, 2) + "\n")
 
   Logger.success(`Login successful! Auth file saved at ${AuthConfigFilePath}`)
@@ -39,7 +42,7 @@ type AuthServer = {
   responseData: Promise<PlaycartResponse>
 }
 
-type PlaycartResponse = z.infer<typeof AuthConfigSchema>
+type PlaycartResponse = z.infer<typeof AuthConfigSchema> | { error: string }
 
 /**
  * The authentication server is created to handle a single redirect from the browser.
@@ -58,7 +61,9 @@ async function createAuthServer(): Promise<AuthServer> {
       expiresAt: url.searchParams.get("expiresAt")
     })
     if (!parsed.success) {
-      throw new InvalidLoginResponseError(`Failed to parse playcart response: ${parsed.error.message}`)
+      const error = `Failed to parse playcart response: ${parsed.error.message}`
+      resolveTokenPromise({ error })
+      throw new InvalidLoginResponseError(error)
     }
     resolveTokenPromise(parsed.data)
   }
@@ -70,11 +75,12 @@ async function createAuthServer(): Promise<AuthServer> {
     server.close()
   })
 
-  const port = await new Promise<number>(resolve => {
+  const port = await new Promise<number>((resolve, reject) => {
     server.listen(0, "localhost", () => {
       const addr = server.address()
       if (!addr || typeof addr !== "object") {
-        throw new Error("Failed to get server address")
+        reject(new Error("Failed to get server address"))
+        return
       }
       resolve(addr.port)
     })

package/src/modules/search-templates/push.ts

@@ -2,8 +2,8 @@ import chalk from "chalk"
 import fs from "fs"
 import path from "path"
 
+import { putWithRetry } from "#api/retry.ts"
 import { fetchSourceFileIfExists } from "#api/source/fetchSourceFile.ts"
-import { putSourceFile } from "#api/source/putSourceFile.ts"
 import { getCachedConfig } from "#config/config.ts"
 import { Logger } from "#console/logger.ts"
 import { promptForConfirmation } from "#console/userPrompt.ts"
@@ -11,9 +11,6 @@ import { calculateTreeHash } from "#filesystem/calculateTreeHash.ts"
 import { listAllFiles, readFileIfExists, writeFile } from "#filesystem/filesystem.ts"
 import { processInBatches } from "#filesystem/processInBatches.ts"
 
-const MAX_RETRIES = 3
-const INITIAL_RETRY_DELAY = 1000 // 1 second
-
 type PushSearchTemplateOptions = {
   // Filter to only push these files. Ignored if empty.
   paths: string[]
@@ -102,20 +99,3 @@ export async function pushSearchTemplate({ paths, force }: PushSearchTemplateOpt
     }
   })
 }
-
-async function putWithRetry(filePath: string, content: string, retryCount = 0): Promise<void> {
-  try {
-    return await putSourceFile(filePath, content)
-  } catch (error: unknown) {
-    if (retryCount >= MAX_RETRIES) {
-      const errorMessage = error instanceof Error ? error.message : String(error)
-      throw new Error(`Failed to push ${filePath} after ${MAX_RETRIES} retries: ${errorMessage}`)
-    }
-    const delay = INITIAL_RETRY_DELAY * Math.pow(2, retryCount)
-    Logger.warn(
-      `${chalk.yellow("⟳")} Failed to push ${chalk.cyan(filePath)}: Retrying in ${delay}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`
-    )
-    await new Promise(resolve => setTimeout(resolve, delay))
-    return putWithRetry(filePath, content, retryCount + 1)
-  }
-}

package/src/modules/setup.ts

@@ -68,9 +68,7 @@ export async function printSetupHelp(projectPath: string, options: Options) {
   const envConfig = getEnvConfig()
   const configToCreate = defaultConfig
   Object.entries(envConfig).forEach(([key, value]) => {
-    if (key in configToCreate) {
-      Object.assign(configToCreate, { [key]: value })
-    }
+    Object.assign(configToCreate, { [key]: value })
   })
 
   const { merchant } = options

package/src/modules/status.ts

@@ -9,7 +9,7 @@ export async function printStatus(projectPath: string) {
     await loadConfig({ projectPath, options: {} })
   } catch (error) {
     if (error instanceof MissingConfigurationError) {
-      Logger.error("Some required configuration is missing\n")
+      // Configuration is missing, we will report it below
     } else {
       throw error
     }

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/test/api/retry.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 
-import { fetchWithRetry } from "#api/retry.ts"
+import { fetchWithRetry, putWithRetry } from "#api/retry.ts"
+import * as putSourceFileModule from "#api/source/putSourceFile.ts"
 import { setupMockConsole } from "#test/utils/mockConsole.ts"
 
 const terminal = setupMockConsole()
@@ -99,4 +100,43 @@ describe("API Retry", () => {
       await assertion
     })
   })
+
+  describe("putWithRetry", () => {
+    let putSourceFileSpy: ReturnType<typeof vi.spyOn>
+
+    beforeEach(() => {
+      vi.clearAllMocks()
+      putSourceFileSpy = vi.spyOn(putSourceFileModule, "putSourceFile")
+    })
+
+    afterEach(() => {
+      putSourceFileSpy.mockRestore()
+    })
+
+    it("should complete successfully on first attempt", async () => {
+      putSourceFileSpy.mockResolvedValue(undefined)
+
+      await putWithRetry("test-file.txt", "content")
+
+      expect(putSourceFileSpy).toHaveBeenCalledTimes(1)
+      expect(putSourceFileSpy).toHaveBeenCalledWith("test-file.txt", "content")
+    })
+
+    it("should use 'push' operation type in error messages", async () => {
+      putSourceFileSpy.mockRejectedValue(new Error("Network error"))
+
+      const retryPromise = putWithRetry("test-file.txt", "content")
+
+      const assertion = expect(retryPromise).rejects.toThrow(
+        "Failed to push test-file.txt after 3 retries: Network error"
+      )
+      await vi.runAllTimersAsync()
+
+      await assertion
+
+      expect(terminal.getSpy("warn")).toHaveBeenCalledWith(
+        expect.stringContaining("Failed to push test-file.txt: Retrying in 1000ms (attempt 1/3)")
+      )
+    })
+  })
 })

package/test/commander.test.ts

@@ -1,6 +1,9 @@
 import { beforeEach, describe, expect, it, MockInstance, vi } from "vitest"
 
+import { clearCachedConfig, getCachedConfig } from "#config/config.ts"
 import { MissingConfigurationError } from "#errors/MissingConfigurationError.ts"
+import * as login from "#modules/login.ts"
+import * as logout from "#modules/logout.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"
@@ -14,6 +17,8 @@ import { setupMockFileSystem } from "./utils/mockFileSystem.ts"
 const fs = setupMockFileSystem()
 const commander = setupMockCommander()
 
+let loginSpy: MockInstance
+let logoutSpy: MockInstance
 let setupSpy: MockInstance
 let statusSpy: MockInstance
 let buildSpy: MockInstance
@@ -22,14 +27,36 @@ let pushSpy: MockInstance
 let devSpy: MockInstance
 
 describe("commander", () => {
-  // Make sure the actual functions are never called
   beforeEach(() => {
+    loginSpy = vi.spyOn(login, "loginToPlaycart").mockImplementation(() => Promise.resolve())
+    logoutSpy = vi.spyOn(logout, "removeLoginCredentials").mockImplementation(() => Promise.resolve())
     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())
+    clearCachedConfig()
+    fs.mockUserAuthentication()
+  })
+
+  describe("nosto login", () => {
+    it("should call the function", async () => {
+      await commander.run("nosto login")
+      expect(loginSpy).toHaveBeenCalledWith()
+    })
+
+    it("should load the config", async () => {
+      await commander.run("nosto login --verbose")
+      expect(getCachedConfig().verbose).toBe(true)
+    })
+  })
+
+  describe("nosto logout", () => {
+    it("should call the function", async () => {
+      await commander.run("nosto logout")
+      expect(logoutSpy).toHaveBeenCalledWith()
+    })
   })
 
   describe("nosto setup", () => {
@@ -143,6 +170,9 @@ describe("commander", () => {
   })
 
   describe("nosto search-templates pull", () => {
+    beforeEach(() => {
+      fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+    })
     it("should pull even without files present", async () => {
       await commander.run("nosto st pull")
       expect(pullSpy).toHaveBeenCalled()
@@ -150,7 +180,6 @@ describe("commander", () => {
 
     describe("with valid environment", () => {
       beforeEach(() => {
-        fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
         fs.writeFile("index.js", "@nosto/preact")
       })
 

package/test/config/authConfig.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest"
+
+import { parseAuthFile } from "#config/authConfig.ts"
+import { AuthConfig } from "#config/schema.ts"
+import { MissingConfigurationError } from "#errors/MissingConfigurationError.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+
+describe("Auth Config", () => {
+  it("should throw if auth file does not exist", () => {
+    expect(() => parseAuthFile({})).toThrowError(MissingConfigurationError)
+    expect(() => parseAuthFile({ allowIncomplete: false })).toThrowError(MissingConfigurationError)
+  })
+
+  it("with allowIncomplete, should return empty auth config if auth file does not exist", () => {
+    const authConfig = parseAuthFile({ allowIncomplete: true })
+    expect(authConfig).toEqual({ user: "", token: "", expiresAt: new Date(0) })
+  })
+
+  it("should parse a valid auth file", () => {
+    const config = {
+      user: "testuser@nosto.com",
+      token: "testtoken",
+      expiresAt: new Date(Date.now() + 1000 * 60 * 60)
+    } satisfies AuthConfig
+
+    fs.writeFile(fs.paths.authFile, config)
+
+    const authConfig = parseAuthFile({})
+    expect(authConfig).toEqual(config)
+  })
+
+  it("should throw an error for invalid auth file JSON", () => {
+    fs.writeFile(fs.paths.authFile, "{ invalidJson: true ")
+
+    expect(() => parseAuthFile({})).toThrowError(/Invalid JSON in auth file/)
+  })
+
+  it("should throw an error for auth file with invalid schema", () => {
+    const invalidConfig = {
+      user: ""
+    }
+
+    fs.writeFile(fs.paths.authFile, invalidConfig)
+
+    expect(() => parseAuthFile({})).toThrowError(/Invalid auth file/)
+  })
+
+  it("should throw an error for a malformed file", () => {
+    fs.writeFile(fs.paths.authFile, "\xff\xfe\xff\xfe")
+
+    expect(() => parseAuthFile({})).toThrowError(/Unexpected token/)
+  })
+
+  it("should throw an error when filesystem throws", () => {
+    fs.writeFile(fs.paths.authFile, {})
+    fs.chmod(fs.paths.authFile, 0o000) // Remove all permissions
+
+    expect(() => parseAuthFile({})).toThrowError(/permission denied/)
+  })
+})

package/test/config/config.test.ts

@@ -0,0 +1,71 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+import { clearCachedConfig, getCachedConfig, getCachedSearchTemplatesConfig, loadConfig } from "#config/config.ts"
+import { PersistentConfigSchema } from "#config/schema.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+const terminal = setupMockConsole()
+
+describe("Config", () => {
+  beforeEach(() => {
+    clearCachedConfig()
+  })
+
+  afterEach(() => {
+    // Clean up environment variables
+    delete process.env.NOSTO_MAX_REQUESTS
+    vi.restoreAllMocks()
+  })
+
+  it("uses cached config on subsequent calls", async () => {
+    fs.mockConfigFile()
+    fs.mockUserAuthentication()
+
+    await loadConfig({ projectPath: ".", options: {} })
+    expect(terminal.getSpy("debug")).not.toHaveBeenCalledWith("Using cached configuration")
+    await loadConfig({ projectPath: ".", options: {} })
+    expect(terminal.getSpy("debug")).toHaveBeenCalledWith("Using cached configuration")
+  })
+
+  it("returns cached config", async () => {
+    fs.mockConfigFile()
+    fs.mockUserAuthentication()
+
+    const config = await loadConfig({ projectPath: ".", options: {} })
+    expect(getCachedConfig()).toEqual(config)
+  })
+
+  it("returns cached search-templates build config", async () => {
+    fs.mockConfigFile()
+    fs.mockUserAuthentication()
+
+    const config = await loadConfig({ projectPath: ".", options: {} })
+    expect(getCachedSearchTemplatesConfig()).toEqual(config.searchTemplates.data)
+  })
+
+  it("throws error with cause when last-chance schema validation fails", async () => {
+    fs.mockUserAuthentication()
+    fs.mockConfigFile()
+
+    // Mock the PersistentConfigSchema.parse to throw an error
+    const mockParse = vi.spyOn(PersistentConfigSchema, "parse")
+    mockParse.mockImplementationOnce(() => {
+      throw new Error("Mocked schema validation error")
+    })
+
+    await expect(loadConfig({ projectPath: ".", options: {} })).rejects.toThrow("Failed to load configuration")
+  })
+
+  it("default implementation of modern config should throw", async () => {
+    fs.mockUserAuthentication()
+    fs.mockConfigFile()
+
+    const config = await loadConfig({ projectPath: ".", options: {} })
+    await expect(config.searchTemplates.data.onBuild()).rejects.toThrow(/not implemented/)
+    await expect(config.searchTemplates.data.onBuildWatch({ onAfterBuild: async () => {} })).rejects.toThrow(
+      /not implemented/
+    )
+  })
+})