@nosto/nosto-cli 1.0.1

package/src/config/schema.ts

@@ -0,0 +1,70 @@
+import z from "zod"
+
+export const LogLevel = ["debug", "info", "warn", "error"] as const
+
+// Persistent per-repo config (.nosto.json file)
+export const PersistentConfigSchema = z.object({
+  merchant: z.string(),
+  apiKey: z.string().optional(),
+  templatesEnv: z.string().default("main"),
+  apiUrl: z.string().default("https://api.nosto.com"),
+  libraryUrl: z.string().default("https://d11ffvpvtnmt0d.cloudfront.net/library"),
+  logLevel: z.enum(LogLevel).default("info"),
+  maxRequests: z.coerce.number().default(15)
+})
+
+// Config provided on runtime (CLI options)
+export const RuntimeConfigSchema = z.object({
+  projectPath: z.string().default("."),
+  dryRun: z.boolean().default(false),
+  verbose: z.boolean().default(false)
+})
+
+// Authentication config (~/nosto/.auth.json file)
+export const AuthConfigSchema = z.object({
+  user: z.string(),
+  token: z.string(),
+  expiresAt: z.coerce.date()
+})
+
+// Environmental variables, alternative to persistent config
+export const EnvironmentConfigSchema = z.object({
+  merchant: z.string().optional(),
+  apiKey: z.string().optional(),
+  templatesEnv: z.string().optional(),
+  apiUrl: z.string().optional(),
+  libraryUrl: z.string().optional(),
+  logLevel: z.enum(LogLevel).optional(),
+  maxRequests: z.coerce.number().optional()
+})
+
+// Modern config, can be committed to repo (nosto.config.ts file)
+export const SearchTemplatesConfigSchema = z.object({
+  onBuild: z
+    .custom<() => Promise<void>>((val): val is () => Promise<void> => typeof val === "function")
+    .default(() => async () => {
+      throw new Error("onBuild function not implemented")
+    }),
+  onBuildWatch: z
+    .custom<(props: OnStartDevProps) => Promise<void>>(
+      (val): val is (props: OnStartDevProps) => Promise<void> => typeof val === "function"
+    )
+    .default(() => async () => {
+      throw new Error("onBuildWatch function not implemented")
+    })
+})
+export type OnStartDevProps = {
+  onAfterBuild: () => Promise<void>
+}
+
+export type SearchTemplatesMode = "modern" | "legacy" | "unknown"
+export type Config = PersistentConfig &
+  RuntimeConfig & { auth: AuthConfig; searchTemplates: { mode: SearchTemplatesMode; data: SearchTemplatesConfig } }
+export type PersistentConfig = z.infer<typeof PersistentConfigSchema>
+export type RuntimeConfig = z.infer<typeof RuntimeConfigSchema>
+export type AuthConfig = z.infer<typeof AuthConfigSchema>
+export type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>
+export type SearchTemplatesConfig = z.infer<typeof SearchTemplatesConfigSchema>
+
+export const PartialPersistentConfigSchema = PersistentConfigSchema.partial()
+export type PartialPersistentConfig = z.infer<typeof PartialPersistentConfigSchema>

package/src/config/searchTemplatesConfig.ts

@@ -0,0 +1,33 @@
+import fs from "fs"
+import path from "path"
+import z from "zod"
+
+import { NostoError } from "#errors/NostoError.ts"
+
+import { type SearchTemplatesConfig, SearchTemplatesConfigSchema, type SearchTemplatesMode } from "./schema.ts"
+
+export async function parseSearchTemplatesConfigFile({
+  projectPath
+}: {
+  projectPath: string
+}): Promise<{ mode: SearchTemplatesMode; data: SearchTemplatesConfig }> {
+  const configPath = path.resolve(projectPath, "nosto.config.ts")
+
+  // If config is not present, assume legacy mode
+  if (!fs.existsSync(configPath)) {
+    return {
+      mode: "legacy",
+      data: SearchTemplatesConfigSchema.parse({})
+    }
+  }
+
+  const defaultExport = await import(configPath).then(module => module.default)
+  const parsedScriptObject = SearchTemplatesConfigSchema.strict().safeParse(defaultExport)
+  if (!parsedScriptObject.success) {
+    throw new NostoError("Invalid nosto.config.ts file: " + z.treeifyError(parsedScriptObject.error))
+  }
+  return {
+    mode: "modern",
+    data: parsedScriptObject.data
+  }
+}

package/src/console/logger.ts

@@ -0,0 +1,93 @@
+import chalk from "chalk"
+
+import { LogLevel } from "#config/schema.ts"
+
+const formatTimestamp = (date: Date): string => {
+  const pad = (num: number) => num.toString().padStart(2, "0")
+  const hours = pad(date.getHours())
+  const minutes = pad(date.getMinutes())
+  const seconds = pad(date.getSeconds())
+  return `${hours}:${minutes}:${seconds}`
+}
+
+const Presets = {
+  debug: () => ({
+    color: chalk.gray,
+    prefix: chalk.gray("[DEBUG]"),
+    logger: console.debug,
+    logLevel: 0
+  }),
+  info: () => ({
+    color: chalk.white,
+    prefix: chalk.white("[INFO] "),
+    logger: console.info,
+    logLevel: 1
+  }),
+  success: () => ({
+    color: chalk.green,
+    prefix: chalk.green("[SUCCESS] "),
+    logger: console.info,
+    logLevel: 1
+  }),
+  warn: () => ({
+    color: chalk.yellow,
+    prefix: chalk.yellow("[WARN] "),
+    logger: console.warn,
+    logLevel: 2
+  }),
+  error: () => ({
+    color: chalk.red,
+    prefix: chalk.red("[ERROR]"),
+    logger: console.error,
+    logLevel: 3
+  })
+}
+
+const printToLog = (message: string, presetFunc: (typeof Presets)[keyof typeof Presets], extra?: unknown) => {
+  const targetLogLevel = LogLevel.indexOf(Logger.context.logLevel)
+  const preset = presetFunc()
+  if (targetLogLevel > preset.logLevel) {
+    return
+  }
+  const timestamp = chalk.dim(formatTimestamp(new Date()))
+  const merchantId = Logger.context.merchantId ? `[${chalk.greenBright(Logger.context.merchantId)}] ` : "| "
+  const dryRun = Logger.context.isDryRun ? chalk.dim("(DRY RUN) ") : ""
+  preset.logger(`${timestamp} ${dryRun}${merchantId}${preset.color(message)}`)
+  if (extra) {
+    preset.logger(chalk.dim(extra, null, 2))
+  }
+}
+
+export const Logger = {
+  context: {
+    logLevel: LogLevel[1] as (typeof LogLevel)[number],
+    merchantId: "",
+    isDryRun: false
+  },
+  raw: (message: string, extra?: unknown) => {
+    console.log(message)
+    if (extra) {
+      console.log(extra)
+    }
+  },
+
+  debug: (message: string, extra?: unknown) => {
+    printToLog(message, Presets.debug, extra)
+  },
+
+  info: (message: string, extra?: unknown) => {
+    printToLog(message, Presets.info, extra)
+  },
+
+  success: (message: string, extra?: unknown) => {
+    printToLog(message, Presets.success, extra)
+  },
+
+  warn: (message: string, extra?: unknown) => {
+    printToLog(message, Presets.warn, extra)
+  },
+
+  error: (message: string, extra?: unknown) => {
+    printToLog(message, Presets.error, extra)
+  }
+}

package/src/console/userPrompt.ts

@@ -0,0 +1,16 @@
+import chalk from "chalk"
+import { createInterface } from "readline/promises"
+
+export async function promptForConfirmation(message: string, defaultAnswer: "Y" | "N"): Promise<boolean> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  const ynPrompt = defaultAnswer === "Y" ? " (Y/n): " : " (y/N): "
+
+  const answer = await rl.question("\n" + message + chalk.gray(ynPrompt))
+  rl.close()
+  const evaluatedAnswer = answer.length === 0 ? defaultAnswer : answer.toUpperCase()
+  return evaluatedAnswer === "Y"
+}

package/src/errors/InvalidLoginResponseError.ts

@@ -0,0 +1,14 @@
+import { Logger } from "#console/logger.ts"
+
+import { NostoError } from "./NostoError.ts"
+
+export class InvalidLoginResponseError extends NostoError {
+  constructor(message: string) {
+    super(message)
+    this.name = "InvalidLoginResponseError"
+  }
+
+  handle() {
+    Logger.error(this.message)
+  }
+}

package/src/errors/MissingConfigurationError.ts

@@ -0,0 +1,14 @@
+import { Logger } from "#console/logger.ts"
+
+import { NostoError } from "./NostoError.ts"
+
+export class MissingConfigurationError extends NostoError {
+  constructor(message: string) {
+    super(message)
+    this.name = "MissingConfigurationError"
+  }
+
+  handle() {
+    Logger.error(this.message)
+  }
+}

package/src/errors/NostoError.ts

@@ -0,0 +1,13 @@
+import { Logger } from "#console/logger.ts"
+
+export class NostoError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "NostoError"
+  }
+
+  handle() {
+    Logger.error(`Generic Nosto error:`)
+    Logger.error(`- ${this.message}`)
+  }
+}

package/src/errors/NotNostoTemplateError.ts

@@ -0,0 +1,15 @@
+import { Logger } from "#console/logger.ts"
+
+import { NostoError } from "./NostoError.ts"
+
+export class NotNostoTemplateError extends NostoError {
+  constructor(message: string) {
+    super(message)
+    this.name = "NotNostoTemplateError"
+  }
+
+  handle() {
+    Logger.error(`This doesn't seem to be a Nosto template folder.`)
+    Logger.error(`- ${this.message}`)
+  }
+}

package/src/errors/withErrorHandler.ts

@@ -0,0 +1,50 @@
+import chalk from "chalk"
+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> {
+  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"))
+      }
+    } 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)
+    } else if (error instanceof NostoError) {
+      error.handle()
+    } else {
+      throw error
+    }
+  }
+}
+
+export function prettyPrintStack(stack: string | undefined) {
+  if (!stack) {
+    return ""
+  }
+  const lines = stack.split("\n")
+  const filteredLines = lines.filter(line => line.includes(".ts"))
+  return filteredLines.join("\n")
+}

package/src/exports.ts

@@ -0,0 +1,8 @@
+import type { SearchTemplatesConfig } from "#config/schema.ts"
+
+/**
+ * No-op helper to enforce type safety.
+ */
+export function makeConfig(args: SearchTemplatesConfig) {
+  return args
+}

package/src/filesystem/asserts/assertGitRepo.ts

@@ -0,0 +1,19 @@
+import chalk from "chalk"
+import fs from "fs"
+import path from "path"
+
+import { getCachedConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+
+export function assertGitRepo() {
+  const { projectPath } = getCachedConfig()
+
+  if (fs.existsSync(path.join(projectPath, ".git"))) {
+    return
+  }
+
+  const gitCommand = projectPath === "." ? "git init" : `cd ${projectPath} && git init`
+  Logger.warn(
+    `We heavily recommend using git for your projects. You can start with just running ${chalk.blueBright(gitCommand)}`
+  )
+}

package/src/filesystem/asserts/assertNostoTemplate.ts

@@ -0,0 +1,34 @@
+import chalk from "chalk"
+import fs from "fs"
+import path from "path"
+
+import { getCachedConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+import { NotNostoTemplateError } from "#errors/NotNostoTemplateError.ts"
+import { isModernTemplateProject } from "#filesystem/legacyUtils.ts"
+
+export function assertNostoTemplate() {
+  const { projectPath } = getCachedConfig()
+
+  Logger.debug("Sanity checking the target directory...")
+  const targetFolder = path.resolve(projectPath)
+  if (!fs.existsSync(targetFolder)) {
+    throw new Error(`Target folder does not exist: ${chalk.cyan(targetFolder)}`)
+  }
+  if (!fs.statSync(targetFolder).isDirectory()) {
+    throw new Error(`Target path is not a directory: ${chalk.cyan(targetFolder)}`)
+  }
+
+  if (isModernTemplateProject()) {
+    return
+  }
+
+  const indexFilePath = path.join(projectPath, "index.js")
+  if (!fs.existsSync(indexFilePath)) {
+    throw new NotNostoTemplateError(`Index file does not exist: ${indexFilePath}`)
+  }
+  const indexFileContent = fs.readFileSync(indexFilePath, "utf-8")
+  if (!indexFileContent.includes("@nosto/preact")) {
+    throw new NotNostoTemplateError(`Index file does not contain @nosto/preact: ${indexFilePath}`)
+  }
+}

package/src/filesystem/calculateTreeHash.ts

@@ -0,0 +1,28 @@
+import crypto from "crypto"
+import fs from "fs"
+
+import { getCachedConfig } from "#config/config.ts"
+
+import { getIgnoreInstance } from "./isIgnored.ts"
+
+export function calculateTreeHash() {
+  const hash = crypto.createHash("sha256")
+  for (const filePath of listAllFilesForHashing()) {
+    const fileContent = fs.readFileSync(filePath, "utf-8")
+    hash.update(fileContent)
+  }
+  return hash.digest("hex")
+}
+
+export function listAllFilesForHashing() {
+  const { projectPath } = getCachedConfig()
+  const allFiles = fs.readdirSync(projectPath, { withFileTypes: true, recursive: true })
+  const ignoreInstance = getIgnoreInstance()
+  const filteredFiles = allFiles
+    .filter(dirent => !ignoreInstance.isIgnored(dirent))
+    .map(dirent => dirent.parentPath + "/" + dirent.name)
+    // To relative path
+    .map(file => file.replace(projectPath + "/", ""))
+    .filter(file => file !== "build/hash")
+  return filteredFiles
+}

package/src/filesystem/esbuild.ts

@@ -0,0 +1,37 @@
+import { context, type Plugin } from "esbuild"
+import path from "path"
+
+import { getCachedConfig } from "#config/config.ts"
+
+import { createLoaderPlugin, notifyOnRebuildPlugin } from "./esbuildPlugins.ts"
+
+export type EsbuildContextOptions = {
+  plugins?: Plugin[]
+}
+
+export function getBuildContext(options: EsbuildContextOptions = {}) {
+  const { plugins = [] } = options
+  const { projectPath } = getCachedConfig()
+  return context({
+    bundle: true,
+    minify: true,
+    write: true,
+    nodePaths: [path.resolve(import.meta.dirname, "../../node_modules")],
+    sourcemap: "linked",
+    treeShaking: true,
+    jsx: "automatic",
+    jsxImportSource: "preact",
+    jsxFragment: "Fragment",
+    metafile: true,
+    target: ["es2018"],
+    supported: {
+      nesting: false // transpile nested CSS to flat
+    },
+    outfile: path.resolve(projectPath, "build/bundle.js"),
+    entryPoints: [path.resolve(projectPath, "index.js")],
+    alias: {
+      "@nosto/preact": path.resolve(projectPath, ".nostocache/library/nosto.module.js")
+    },
+    plugins: [createLoaderPlugin(), notifyOnRebuildPlugin(), ...plugins]
+  })
+}

package/src/filesystem/esbuildPlugins.ts

@@ -0,0 +1,72 @@
+import path from "node:path"
+
+import chalk from "chalk"
+import * as esbuild from "esbuild"
+import fs from "fs"
+
+import { getCachedConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+import { getLoaderScript } from "#filesystem/utils/getLoaderScript.ts"
+import { pushSearchTemplate } from "#modules/search-templates/push.ts"
+
+export function createLoaderPlugin(): esbuild.Plugin {
+  return {
+    name: "create-loader",
+    setup(build) {
+      build.onEnd(result => {
+        if (result.errors.length) {
+          return
+        }
+        Logger.debug("Generating loader script...")
+        const { projectPath } = getCachedConfig()
+        const outUri = path.join(projectPath, "build")
+        fs.writeFileSync(path.join(outUri, "loader.js"), getLoaderScript())
+      })
+    }
+  }
+}
+
+/**
+ * By default, esbuild is silent. This plugin prints a log message with some rebuild stats.
+ */
+const performanceStats = {
+  lastBuildStartedAt: 0
+}
+export function notifyOnRebuildPlugin(): esbuild.Plugin {
+  return {
+    name: "notify-on-rebuild",
+    setup(build) {
+      build.onStart(() => {
+        performanceStats.lastBuildStartedAt = performance.now()
+      })
+      build.onEnd(result => {
+        if (result.errors.length) {
+          return
+        }
+        const duration = performance.now() - performanceStats.lastBuildStartedAt
+        Logger.info(`Templates built in ${chalk.green(Math.round(duration) + " ms")}.`)
+      })
+    }
+  }
+}
+
+export function pushOnRebuildPlugin(): esbuild.Plugin {
+  return {
+    name: "push-on-rebuild",
+    setup(build) {
+      build.onEnd(result => {
+        if (result.errors.length) {
+          return
+        }
+
+        // Only push built files
+        const { projectPath } = getCachedConfig()
+        const buildPath = path.resolve(projectPath, "build")
+        const files = fs.readdirSync(buildPath)
+        const paths = files.map(file => path.relative(projectPath, path.resolve(buildPath, file)))
+
+        pushSearchTemplate({ paths, force: false })
+      })
+    }
+  }
+}

package/src/filesystem/filesystem.ts

@@ -0,0 +1,40 @@
+import fs from "fs"
+import path from "path"
+
+import { getCachedConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+
+import { getIgnoreInstance } from "./isIgnored.ts"
+
+export function writeFile(pathToWrite: string, data: string) {
+  if (getCachedConfig().dryRun) {
+    return
+  }
+  if (!fs.existsSync(path.dirname(pathToWrite))) {
+    Logger.debug(`Creating directory: ${path.dirname(pathToWrite)}`)
+    fs.mkdirSync(path.dirname(pathToWrite), { recursive: true })
+  }
+  Logger.debug(`Writing to file: ${pathToWrite}`)
+  fs.writeFileSync(pathToWrite, data)
+}
+
+export function readFileIfExists(pathToRead: string) {
+  if (fs.existsSync(pathToRead)) {
+    return fs.readFileSync(pathToRead, "utf-8")
+  }
+  return null
+}
+
+export function listAllFiles(folder: string) {
+  const allDirents = fs.readdirSync(folder, { withFileTypes: true, recursive: true })
+  const allFiles = allDirents.filter(dirent => !dirent.isDirectory())
+  const ignoreInstance = getIgnoreInstance()
+  const filteredFiles = allFiles
+    .filter(dirent => !ignoreInstance.isIgnored(dirent))
+    .map(dirent => dirent.parentPath + "/" + dirent.name)
+    .map(file => path.relative(folder, file))
+  return {
+    allFiles: filteredFiles,
+    unfilteredFileCount: allFiles.length
+  }
+}

package/src/filesystem/isIgnored.ts

@@ -0,0 +1,65 @@
+import { Dirent } from "fs"
+import fs from "fs"
+import type { Ignore } from "ignore"
+import ignore from "ignore"
+import path from "path"
+
+import { getCachedConfig } from "#config/config.ts"
+
+/**
+ * The build directory is never ignored even if it's in the .gitignore file
+ */
+function isNeverIgnored(dirent: Dirent): boolean {
+  const { projectPath } = getCachedConfig()
+  const absoluteProjectPath = path.resolve(projectPath)
+
+  return (
+    dirent.parentPath.startsWith(path.join(projectPath, "build")) ||
+    dirent.parentPath.startsWith(path.join(absoluteProjectPath, "build"))
+  )
+}
+
+function isIgnoredImplicitly(dirent: Dirent): boolean {
+  const parentPathSections = dirent.parentPath.split("/")
+  if (
+    !dirent.isFile() ||
+    dirent.name.startsWith(".") ||
+    dirent.name.includes("node_modules") ||
+    parentPathSections.some(section => section !== "." && section.startsWith("."))
+  ) {
+    return true
+  }
+
+  return false
+}
+
+export function isIgnoredExplicitly(instance: Ignore, dirent: Dirent): boolean {
+  const { projectPath } = getCachedConfig()
+  const absoluteProjectPath = path.resolve(projectPath)
+  const relativePath = dirent.parentPath
+    ? path.relative(absoluteProjectPath, path.join(dirent.parentPath, dirent.name))
+    : dirent.name
+  return instance.ignores(relativePath)
+}
+
+export function getIgnoreInstance() {
+  const { projectPath } = getCachedConfig()
+
+  const gitignorePath = path.join(projectPath, ".gitignore")
+  const patterns: string[] = fs.existsSync(gitignorePath)
+    ? fs
+        .readFileSync(gitignorePath, "utf-8")
+        .split(/\r?\n/)
+        .filter(line => line.trim() && !line.startsWith("#"))
+    : []
+
+  const instance = ignore().add(patterns)
+  return {
+    isIgnored: (dirent: Dirent) => {
+      if (isNeverIgnored(dirent)) {
+        return false
+      }
+      return isIgnoredImplicitly(dirent) || isIgnoredExplicitly(instance, dirent)
+    }
+  }
+}

package/src/filesystem/legacyUtils.ts

@@ -0,0 +1,10 @@
+import fs from "fs"
+import path from "path"
+
+import { getCachedConfig } from "#config/config.ts"
+
+export function isModernTemplateProject() {
+  const { projectPath } = getCachedConfig()
+  const deployManifest = path.resolve(projectPath, "nosto.config.ts")
+  return fs.existsSync(deployManifest)
+}

package/src/filesystem/loadLibrary.ts

@@ -0,0 +1,31 @@
+import chalk from "chalk"
+import path from "path"
+
+import { fetchLibraryFile } from "#api/library/fetchLibraryFile.ts"
+import { fetchWithRetry } from "#api/retry.ts"
+import { cleanUrl } from "#api/utils.ts"
+import { Logger } from "#console/logger.ts"
+
+import { writeFile } from "./filesystem.ts"
+
+export async function loadLibrary(libraryPath: string) {
+  const filesToLoad = ["/nosto.module.js", "/nosto.module.js.map", "/nosto.d.ts"]
+  let filesFetched = 0
+  const fileCount = filesToLoad.length
+  const promises = filesToLoad.map(async filename => {
+    const data = await fetchWithRetry(fetchLibraryFile, filename)
+    filesFetched++
+    Logger.info(
+      `${chalk.green("✓")} [${filesFetched}/${fileCount}] ${chalk.blue("↓")} ${chalk.cyan(cleanUrl(filename))}`
+    )
+    return {
+      data,
+      filename
+    }
+  })
+  const files = await Promise.all(promises)
+  files.forEach(({ data, filename }) => {
+    const filePath = path.join(libraryPath, filename)
+    writeFile(filePath, data)
+  })
+}