@erdoai/cli 0.54.1 → 0.55.1

package/README.md

@@ -87,6 +87,21 @@ erdo --org 2200-brickell datasets query 2200-brickell.page-events \
   "which pages get the most views, and how many convert?"
 ```
 
+**A file dataset keeps the versions it overwrote.** Its contents are stored, and
+each write that replaces them keeps the version it replaced, so an import that
+landed bad rows over good ones has not destroyed them. List the versions, then
+read one back with `fetch` — the same SQL you would run against the live table.
+
+```bash
+erdo datasets revisions acme.leads               # live version first, then superseded
+erdo datasets fetch acme.leads --revision <id> \
+  --sql "SELECT * FROM data"                     # query those older contents
+```
+
+The history is read-only: nothing here rolls a dataset back. Restoring means
+fetching the rows out of the old revision and writing them in again through the
+normal write path.
+
 ```bash
 erdo datasets list                     # slug, type, status, class, name
 erdo datasets upload ./leads.csv       # create a dataset from a file

package/dist/index.js

@@ -713,6 +713,9 @@ var ErdoClient = class {
   // named saved filters. filter_names are additive on top of the dataset's default
   // filters — they narrow the result, never bypass a default. An unknown name is
   // rejected server-side with the available names.
+  //
+  // revision_id runs the same read against a superseded storage revision instead
+  // of the dataset's live contents — the ids come from listDatasetRevisions.
   fetchDatasetContents(slug, opts) {
     return this.request(
       "POST",
@@ -720,10 +723,21 @@ var ErdoClient = class {
       {
         sql_query: opts.sql_query,
         limit: opts.limit,
-        filter_names: opts.filter_names
+        filter_names: opts.filter_names,
+        revision_id: opts.revision_id
       }
     );
   }
+  // A file dataset's storage is versioned: every write that replaces its contents
+  // keeps the version it replaced, and this lists them — the live (primary) one
+  // first, then superseded ones newest first. superseded_at is the moment a newer
+  // version took over, and is null both on the live revision and on a stored file
+  // that was never live (an upload merged into an existing table); file_type may be
+  // absent when the stored file's type was never recorded. Read one back by passing
+  // its id as revision_id to fetchDatasetContents.
+  listDatasetRevisions(slug) {
+    return this.request("GET", `/v1/datasets/${encodeURIComponent(slug)}/revisions`);
+  }
   uploadDatasetFile(body) {
     return this.request("POST", "/v1/datasets-upload", body);
   }
@@ -769,6 +783,12 @@ var ErdoClient = class {
   connectIntegration(body) {
     return this.request("POST", "/v1/integrations-connect", body);
   }
+  // `connected` reports whether the connection exists, which is not the same as
+  // whether it works: a key retired at the provider leaves status 'connected'
+  // here, because the connector platform keeps signing calls with it and simply
+  // relays the provider's refusal. `provider_auth_failed_at` is when that last
+  // happened, and the `note` says so in words — a connection carrying one needs
+  // reauthorizing even though nothing else looks wrong.
   checkIntegrationConnection(app) {
     return this.request("GET", `/v1/integrations-connect/${encodeURIComponent(app)}`);
   }
@@ -3464,14 +3484,57 @@ datasetsCmd.command("fetch <slug>").description(
   "opt into a saved filter by name (repeatable); additive on top of the dataset's default filters (see: erdo datasets filter list <slug>)",
   (v, acc) => acc.concat(v),
   []
-).action(async (slug, opts) => {
+).option(
+  "--revision <id>",
+  "read a superseded storage revision instead of the live table \u2014 the same SQL runs against the contents this id names, so a version that was overwritten is still queryable (see: erdo datasets revisions <slug> for the ids)"
+).action(
+  async (slug, opts) => {
+    try {
+      print(
+        await new ErdoClient().fetchDatasetContents(slug, {
+          sql_query: opts.sql,
+          limit: opts.limit,
+          filter_names: opts.filter.length ? opts.filter : void 0,
+          revision_id: opts.revision
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+datasetsCmd.command("revisions <slug>").description(
+  "List the stored versions of a file dataset's contents. Every write that replaces a file dataset keeps the version it replaced, so an import that overwrote good rows with bad ones has not lost them: this lists the live version first and the superseded ones newest first, and each row's id is what `datasets fetch <slug> --revision <id>` reads \u2014 the same SQL, run against those older contents. History is read-only and nothing here rolls a dataset back; restoring means fetching the rows out of the old revision and writing them in again through the normal write path."
+).option("--json", "print the raw JSON result instead of a table").action(async (slug, opts) => {
   try {
-    print(
-      await new ErdoClient().fetchDatasetContents(slug, {
-        sql_query: opts.sql,
-        limit: opts.limit,
-        filter_names: opts.filter.length ? opts.filter : void 0
-      })
+    const res = await new ErdoClient().listDatasetRevisions(slug);
+    if (opts.json) {
+      print(res);
+      return;
+    }
+    const revisions = res.revisions ?? [];
+    if (revisions.length === 0) {
+      console.log(
+        `${res.dataset_slug} has no stored revisions \u2014 versions are kept for file datasets, whose contents Erdo stores and replaces on each write. A database or warehouse dataset is queried live at its source and keeps no history here.`
+      );
+      return;
+    }
+    printAlignedTable(
+      ["id", "created", "superseded", "live", "name", "type"],
+      revisions.map((r) => [
+        r.id,
+        r.created_at,
+        r.superseded_at ?? "",
+        r.is_primary ? "yes" : "",
+        r.display_name,
+        // file_type is the specific answer (csv, xlsx) and item_type the general
+        // one; the more specific wins when it was recorded.
+        r.file_type || r.item_type
+      ])
+    );
+    console.log(
+      `
+Read one with: erdo datasets fetch ${res.dataset_slug} --revision <id> --sql "SELECT * FROM data"`
     );
   } catch (e) {
     fail(e);
@@ -3650,7 +3713,7 @@ integrationsCmd.command("apps [query]").description("Search connectable apps (na
     fail(e);
   }
 });
-integrationsCmd.command("connect <app>").description("Connect an app \u2014 pass its API key or other credentials with -c, or omit them to get a browser connect URL for OAuth apps").option("-c, --credential <key=value...>", "credential field, e.g. -c api_key=\u2026 (repeatable); rejected by OAuth apps, which have no credential to pass", (v, acc) => acc.concat(v), []).option("-n, --name <name>", "display name for the connection").action(async (app, opts) => {
+integrationsCmd.command("connect <app>").description("Connect an app \u2014 pass its API key or other credentials with -c, or omit them to get a browser connect URL for OAuth apps").option("-c, --credential <key=value...>", "credential field, e.g. -c api_key=\u2026 (repeatable); rejected by OAuth apps, which have no credential to pass", (v, acc) => acc.concat(v), []).option("-n, --name <name>", "display name for the connection").option("--rotate", "replace the credentials of the app's existing connection instead of adding a second one \u2014 for a key that was rotated at the provider; requires -c").action(async (app, opts) => {
   try {
     let credentials;
     if (opts.credential.length) {
@@ -3661,7 +3724,12 @@ integrationsCmd.command("connect <app>").description("Connect an app \u2014 pass
         credentials[c.slice(0, eq)] = c.slice(eq + 1);
       }
     }
-    const res = await new ErdoClient().connectIntegration({ app, name: opts.name, credentials });
+    const res = await new ErdoClient().connectIntegration({
+      app,
+      name: opts.name,
+      credentials,
+      rotate_credentials: opts.rotate || void 0
+    });
     print(res);
     const notes = [];
     const org2 = formatOrg(res.organization_name, res.organization_slug);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erdoai/cli",
-  "version": "0.54.1",
+  "version": "0.55.1",
   "description": "Erdo CLI — drive datasets, pages, and evals from the terminal or CI",
   "type": "module",
   "bin": {