@frontera-sdk/cli 1.45.7 → 1.45.8

package/src/commands/knowledge/upload-batch.ts

@@ -121,6 +121,61 @@ export function summarizeUploads(
  * the count of what did not land has to be the first thing on the page rather
  * than a column someone has to notice.
  */
+/**
+ * How many source rows already carry these filenames.
+ *
+ * A failed upload does NOT mean nothing was recorded: the service registers the
+ * source and then fails downstream — ingestion, embedding — so `all 1
+ * upload(s) failed` was printed while a `pending` row sat in the base. Retrying
+ * added a second row for the same file, which is the opposite of the "a retry
+ * duplicates nothing" the hint used to promise.
+ *
+ * Counted rather than guessed, and matched on the filename because that is all
+ * a failed upload leaves behind — no id comes back. Names are not unique, so
+ * this is reported as "rows carrying this name", never as "your upload".
+ */
+export async function countExistingSources(
+  api: { knowledgeSources(id: string): Promise<unknown[]> },
+  baseId: string,
+  filenames: string[],
+): Promise<Map<string, number>> {
+  const wanted = new Set(filenames)
+  const counts = new Map<string, number>()
+  // Best effort: this runs on a path that is already failing, and a second
+  // failure here must not replace the cause the caller needs to see.
+  const rows = await api.knowledgeSources(baseId).catch(() => [] as unknown[])
+  for (const row of rows as Array<{ fileName?: string }>) {
+    const name = row?.fileName
+    if (!name || !wanted.has(name)) continue
+    counts.set(name, (counts.get(name) ?? 0) + 1)
+  }
+  return counts
+}
+
+/**
+ * What to say about rows a failed upload may have left behind.
+ *
+ * Returns `undefined` when there is nothing to warn about, so a clean failure
+ * keeps a clean message.
+ */
+export function describeExistingSources(counts: Map<string, number>): string | undefined {
+  const present = [...counts.entries()].filter(([, n]) => n > 0)
+  if (present.length === 0) return undefined
+
+  const total = present.reduce((sum, [, n]) => sum + n, 0)
+  const duplicated = present.filter(([, n]) => n > 1)
+  return (
+    `${total} source row${total === 1 ? '' : 's'} already `
+    + `${total === 1 ? 'carries' : 'carry'} `
+    + `${present.length === 1 ? 'that filename' : 'those filenames'}`
+    + (duplicated.length > 0
+      ? `, and ${duplicated.length} filename${duplicated.length === 1 ? '' : 's'} `
+        + `${duplicated.length === 1 ? 'has' : 'have'} more than one — `
+        + 'a failed upload still registers a source, so re-running adds another'
+      : ' — a failed upload still registers a source')
+  )
+}
+
 export function renderUploadSummary(summary: UploadSummary): string {
   const lines: string[] = []
   const total = summary.sources.length

package/src/commands/source/index-commands.ts

@@ -172,7 +172,85 @@ function requireConfig(doc: SourceFile, path: string): Record<string, unknown> {
       hint: 'config: { kind: "postgres", host, port, database, username, sslMode, connectTimeoutMs }',
     })
   }
-  return doc.config as Record<string, unknown>
+  const config = doc.config as Record<string, unknown>
+  validateConnectionConfig(config, path)
+  return config
+}
+
+const SSL_MODES = ['require', 'verify-ca', 'verify-full', 'disable']
+
+/**
+ * The connection block, checked here for the reason `validateDatasets` gives.
+ *
+ * That function exists because the service's refusal for this body names the
+ * wrong field — `strictJsonBody` substitutes a sentinel that omits `mode`, so
+ * ANY failure anywhere in the document comes back as "Expected 'virtual' at
+ * /datasets/0/mode". It pre-empted that for `datasets` and not for `config`,
+ * which left the commonest mistakes unreachable: a `config` missing `kind` or
+ * `connectTimeoutMs` was reported as a bad `mode` on a dataset whose `mode` was
+ * already `"virtual"`.
+ *
+ * That is how `source create` came to look like a write path with no passing
+ * document. It has one — the errors were describing the wrong half of the file.
+ *
+ * `password` is deliberately absent: it never travels in the file, and a file
+ * carrying one is refused rather than stripped, above.
+ */
+export function validateConnectionConfig(config: Record<string, unknown>, path: string): void {
+  const where = `${path}: config`
+
+  if (config.kind !== 'postgres') {
+    throw new CliError(`${where} has kind ${JSON.stringify(config.kind)}.`, {
+      code: 'USAGE',
+      hint: 'kind must be "postgres" — it is the only connector the service accepts today',
+    })
+  }
+
+  for (const field of ['host', 'database', 'username'] as const) {
+    const value = config[field]
+    if (typeof value !== 'string' || value.length === 0) {
+      throw new CliError(`${where}.${field} is ${JSON.stringify(value)}.`, {
+        code: 'USAGE',
+        hint: `${field} must be a non-empty string`,
+      })
+    }
+  }
+
+  const port = config.port
+  if (!Number.isInteger(port) || (port as number) < 1 || (port as number) > 65_535) {
+    throw new CliError(`${where}.port is ${JSON.stringify(port)}.`, {
+      code: 'USAGE',
+      hint: 'port must be a whole number between 1 and 65535 — 5432 for a default PostgreSQL',
+    })
+  }
+
+  if (typeof config.sslMode !== 'string' || !SSL_MODES.includes(config.sslMode)) {
+    throw new CliError(`${where}.sslMode is ${JSON.stringify(config.sslMode)}.`, {
+      code: 'USAGE',
+      hint: `sslMode must be one of: ${SSL_MODES.join(', ')}`,
+    })
+  }
+
+  const timeout = config.connectTimeoutMs
+  if (!Number.isInteger(timeout) || (timeout as number) < 1_000 || (timeout as number) > 15_000) {
+    throw new CliError(`${where}.connectTimeoutMs is ${JSON.stringify(timeout)}.`, {
+      code: 'USAGE',
+      // Easily missed: it has no sensible default the CLI could supply, because
+      // the right value depends on where the database is.
+      hint: 'connectTimeoutMs must be a whole number of milliseconds between 1000 and 15000',
+    })
+  }
+
+  // The service sets `additionalProperties: false`, so an extra key fails the
+  // whole document — and fails it by naming a dataset's `mode`.
+  const KNOWN = new Set(['kind', 'host', 'port', 'database', 'username', 'sslMode', 'connectTimeoutMs'])
+  const unknown = Object.keys(config).filter((key) => !KNOWN.has(key))
+  if (unknown.length > 0) {
+    throw new CliError(`${where} carries unknown field(s): ${unknown.join(', ')}.`, {
+      code: 'USAGE',
+      hint: `config accepts exactly: ${[...KNOWN].join(', ')}`,
+    })
+  }
 }
 
 const list: Command = {