0.1.1

Author: alxnddr

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metabase/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Metabase CLI",
   "license": "AGPL-3.0",
   "repository": {

src/commands/card/query.ts

@@ -109,7 +109,7 @@ function parseExportFormat(raw: string): ExportFormat {
 }
 
 function applyLimit(result: CardQueryResult, limit: number | null): CardQueryResult {
-  if (limit === null || result.status !== "completed" || result.data.rows.length <= limit) {
+  if (limit === null || result.data === undefined || result.data.rows.length <= limit) {
     return result;
   }
   return { ...result, data: { ...result.data, rows: result.data.rows.slice(0, limit) } };

src/commands/collection/items.ts

@@ -1,9 +1,9 @@
 import {
-  COLLECTION_ITEM_MODELS,
+  COLLECTION_ITEM_FILTER_MODELS,
   COLLECTION_PINNED_STATES,
   CollectionItem,
   CollectionItemCompact,
-  CollectionItemModel,
+  CollectionItemFilterModel,
   CollectionPinnedState,
   collectionItemView,
 } from "../../domain/collection";
@@ -32,7 +32,7 @@ export default defineMetabaseCommand({
     },
     models: {
       type: "string",
-      description: `Comma-separated model filter: ${COLLECTION_ITEM_MODELS.join(",")}`,
+      description: `Comma-separated model filter: ${COLLECTION_ITEM_FILTER_MODELS.join(",")}`,
       alias: "m",
     },
     archived: {
@@ -58,7 +58,7 @@ export default defineMetabaseCommand({
   ],
   async run({ args, ctx, getClient }) {
     const ref = parseCollectionRef(args.id);
-    const models = parseEnumCsv(args.models, CollectionItemModel, "--models");
+    const models = parseEnumCsv(args.models, CollectionItemFilterModel, "--models");
     const pinnedState = parseEnum(args["pinned-state"], CollectionPinnedState, "--pinned-state");
     const max = args.limit === undefined ? undefined : parseId(args.limit, "--limit");
     const client = await getClient();

src/commands/dashboard/update-dashcard.ts

@@ -44,7 +44,7 @@ export default defineMetabaseCommand({
     }
     const patched = Dashcard.parse({ ...target, ...patch });
     const updatedDashcards = dashboard.dashcards.map((dashcard) =>
-      dashcard.id === dashcardId ? patched : dashcard,
+      stripEntityId(dashcard.id === dashcardId ? patched : dashcard),
     );
 
     const result = await client.requestParsed(DashboardDetail, `/api/dashboard/${dashboardId}`, {
@@ -60,3 +60,8 @@ export default defineMetabaseCommand({
     renderItem(refreshed, dashcardView, ctx);
   },
 });
+
+function stripEntityId(dashcard: Dashcard): Omit<Dashcard, "entity_id"> {
+  const { entity_id: _entity_id, ...rest } = dashcard;
+  return rest;
+}

src/domain/card.ts

@@ -74,7 +74,7 @@ export const CardCreateInput = z
     dataset_query: CardDatasetQuery,
     display: z.string().min(1),
     visualization_settings: z.record(z.string(), z.unknown()),
-    description: z.string().nullable().optional(),
+    description: z.string().min(1).nullable().optional(),
     collection_id: z.number().int().positive().nullable().optional(),
     collection_position: z.number().int().positive().nullable().optional(),
     dashboard_id: z.number().int().positive().nullable().optional(),
@@ -118,33 +118,22 @@ const QueryColumn = z
   })
   .loose();
 
-const CardQueryDataCompleted = z
+const CardQueryData = z
   .object({
     rows: z.array(z.unknown()),
     cols: z.array(QueryColumn),
   })
   .loose();
 
-const CardQueryCompleted = z
-  .object({
-    status: z.literal("completed"),
-    row_count: z.number().int().nonnegative(),
-    data: CardQueryDataCompleted,
-  })
-  .loose();
-
-const CardQueryFailed = z
+export const CardQueryResult = z
   .object({
-    status: z.literal("failed"),
+    status: z.string(),
+    row_count: z.number().int().nonnegative().optional(),
+    data: CardQueryData.optional(),
     error: z.string().nullable().optional(),
     error_type: z.string().nullable().optional(),
   })
   .loose();
-
-export const CardQueryResult = z.discriminatedUnion("status", [
-  CardQueryCompleted,
-  CardQueryFailed,
-]);
 export type CardQueryResult = z.infer<typeof CardQueryResult>;
 
 export const cardQueryView: ResourceView<CardQueryResult> = {

src/domain/collection.ts

@@ -10,30 +10,21 @@ const CollectionAuthorityLevel = z.enum(["official"]);
 const CollectionType = z.enum([
   "instance-analytics",
   "trash",
-  "remote-synced",
   "library",
   "library-data",
   "library-metrics",
-  "shared-tenant-collection",
   "tenant-specific-root-collection",
 ]);
 
-const CollectionNamespace = z.enum([
-  "snippets",
-  "transforms",
-  "analytics",
-  "tenant-specific",
-  "shared-tenant-collection",
-]);
+const CollectionNamespace = z.string().min(1);
 
-export const COLLECTION_ITEM_MODELS = [
+export const COLLECTION_ITEM_FILTER_MODELS = [
   "card",
   "dataset",
   "metric",
   "dashboard",
   "snippet",
   "collection",
-  "indexed-entity",
   "document",
   "table",
   "transform",
@@ -42,6 +33,11 @@ export const COLLECTION_ITEM_MODELS = [
   "timeline",
   "no_models",
 ] as const;
+export const CollectionItemFilterModel = z.enum(COLLECTION_ITEM_FILTER_MODELS);
+export type CollectionItemFilterModel = z.infer<typeof CollectionItemFilterModel>;
+
+// `indexed-entity` is a valid response model but not accepted as a filter value.
+export const COLLECTION_ITEM_MODELS = [...COLLECTION_ITEM_FILTER_MODELS, "indexed-entity"] as const;
 export const CollectionItemModel = z.enum(COLLECTION_ITEM_MODELS);
 export type CollectionItemModel = z.infer<typeof CollectionItemModel>;
 

src/domain/field.ts

@@ -189,12 +189,14 @@ export const fieldView: ResourceView<Field> = {
   ],
 };
 
+const NonBlankNullable = z.string().min(1).nullable();
+
 export const FieldUpdateInput = z
   .object({
     display_name: z.string().min(1).optional(),
-    description: z.string().nullable().optional(),
-    caveats: z.string().nullable().optional(),
-    points_of_interest: z.string().nullable().optional(),
+    description: NonBlankNullable.optional(),
+    caveats: NonBlankNullable.optional(),
+    points_of_interest: NonBlankNullable.optional(),
     semantic_type: FieldSemanticType.nullable().optional(),
     coercion_strategy: FieldCoercionStrategy.nullable().optional(),
     fk_target_field_id: z.number().int().positive().nullable().optional(),

tests/e2e/card-query.ts

@@ -0,0 +1,14 @@
+import { CardQueryResult } from "../../src/domain/card";
+
+type CompletedCardQueryResult = CardQueryResult & { data: NonNullable<CardQueryResult["data"]> };
+
+export function assertCompletedQuery(
+  result: CardQueryResult,
+): asserts result is CompletedCardQueryResult {
+  if (result.status !== "completed") {
+    throw new Error(`expected status "completed", got "${result.status}"`);
+  }
+  if (result.data === undefined) {
+    throw new Error(`expected data to be defined; got: ${JSON.stringify(result)}`);
+  }
+}

tests/e2e/card.e2e.test.ts

@@ -6,6 +6,7 @@ import { Card, CardCompact, CardQueryResult } from "../../src/domain/card";
 import { parseJson } from "../../src/runtime/json";
 
 import { readBootstrap, type E2EBootstrap } from "./bootstrap-data";
+import { assertCompletedQuery } from "./card-query";
 import { cleanupConfigHome, mkTempConfigHome, runCli } from "./run-cli";
 import { E2E_CARDS, E2E_COLLECTIONS, E2E_DATABASES, E2E_TABLES } from "./seed/ids";
 
@@ -196,9 +197,7 @@ describe("card e2e", () => {
 
     expect(result.exitCode, result.stderr).toBe(0);
     const parsed = parseJson(result.stdout, CardQueryResult);
-    if (parsed.status !== "completed") {
-      throw new Error(`expected status "completed", got "${parsed.status}"`);
-    }
+    assertCompletedQuery(parsed);
     expect({
       status: parsed.status,
       row_count: parsed.row_count,
@@ -221,9 +220,7 @@ describe("card e2e", () => {
 
     expect(result.exitCode, result.stderr).toBe(0);
     const parsed = parseJson(result.stdout, CardQueryResult);
-    if (parsed.status !== "completed") {
-      throw new Error(`expected status "completed", got "${parsed.status}"`);
-    }
+    assertCompletedQuery(parsed);
     expect({
       rowsLength: parsed.data.rows.length,
       row_count: parsed.row_count,

tests/e2e/query.e2e.test.ts

@@ -9,6 +9,7 @@ import { CardQueryResult } from "../../src/domain/card";
 import { parseJson } from "../../src/runtime/json";
 
 import { readBootstrap, type E2EBootstrap } from "./bootstrap-data";
+import { assertCompletedQuery } from "./card-query";
 import { cleanupConfigHome, mkTempConfigHome, runCli } from "./run-cli";
 import { E2E_DATABASES, E2E_TABLES } from "./seed/ids";
 
@@ -203,11 +204,9 @@ describe("query e2e", () => {
 
     expect(result.exitCode, result.stderr).toBe(0);
     const queryResult = parseJson(result.stdout, CardQueryResult);
-    expect(queryResult.status).toBe("completed");
-    if (queryResult.status === "completed") {
-      expect(queryResult.row_count).toBe(3);
-      expect(queryResult.data.rows).toHaveLength(3);
-    }
+    assertCompletedQuery(queryResult);
+    expect(queryResult.row_count).toBe(3);
+    expect(queryResult.data.rows).toHaveLength(3);
   });
 
   it("run with a legacy native body skips MBQL 5 pre-flight and executes against /api/dataset", async () => {
@@ -225,11 +224,9 @@ describe("query e2e", () => {
 
     expect(result.exitCode, result.stderr).toBe(0);
     const queryResult = parseJson(result.stdout, CardQueryResult);
-    expect(queryResult.status).toBe("completed");
-    if (queryResult.status === "completed") {
-      expect(queryResult.row_count).toBe(1);
-      expect(queryResult.data.rows).toEqual([[1, 2]]);
-    }
+    assertCompletedQuery(queryResult);
+    expect(queryResult.row_count).toBe(1);
+    expect(queryResult.data.rows).toEqual([[1, 2]]);
   });
 
   it("--dry-run with a legacy native body returns ok and exits 0 (no schema applies)", async () => {
@@ -266,11 +263,9 @@ describe("query e2e", () => {
 
     expect(result.exitCode, result.stderr).toBe(0);
     const queryResult = parseJson(result.stdout, CardQueryResult);
-    expect(queryResult.status).toBe("completed");
-    if (queryResult.status === "completed") {
-      expect(queryResult.row_count).toBe(3);
-      expect(queryResult.data.rows).toHaveLength(3);
-    }
+    assertCompletedQuery(queryResult);
+    expect(queryResult.row_count).toBe(3);
+    expect(queryResult.data.rows).toHaveLength(3);
   });
 
   it("--dry-run with a legacy MBQL 4 body returns ok and exits 0 (server normalizes; no MBQL 5 schema applies)", async () => {