metabase-cli 0.2.2

package/dist/index.js

@@ -0,0 +1,735 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CardApi: () => CardApi,
+  CollectionApi: () => CollectionApi,
+  DashboardApi: () => DashboardApi,
+  DatabaseApi: () => DatabaseApi,
+  DatasetApi: () => DatasetApi,
+  FieldApi: () => FieldApi,
+  MetabaseClient: () => MetabaseClient,
+  SafetyGuard: () => SafetyGuard,
+  SearchApi: () => SearchApi,
+  SessionApi: () => SessionApi,
+  SnippetApi: () => SnippetApi,
+  TableApi: () => TableApi,
+  UserApi: () => UserApi,
+  addProfile: () => addProfile,
+  formatDatasetResponse: () => formatDatasetResponse,
+  formatEntityTable: () => formatEntityTable,
+  formatJson: () => formatJson,
+  getActiveProfile: () => getActiveProfile,
+  listProfiles: () => listProfiles,
+  loadConfig: () => loadConfig,
+  removeProfile: () => removeProfile,
+  saveConfig: () => saveConfig,
+  setActiveProfile: () => setActiveProfile,
+  updateProfile: () => updateProfile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/store.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+function getConfigDir() {
+  return path.join(os.homedir(), ".metabase-cli");
+}
+function getConfigFile() {
+  return path.join(getConfigDir(), "config.json");
+}
+function ensureConfigDir() {
+  if (!fs.existsSync(getConfigDir())) {
+    fs.mkdirSync(getConfigDir(), { recursive: true, mode: 448 });
+  }
+}
+function defaultConfig() {
+  return { activeProfile: "", profiles: {} };
+}
+function loadConfig() {
+  ensureConfigDir();
+  if (!fs.existsSync(getConfigFile())) {
+    return defaultConfig();
+  }
+  const raw = fs.readFileSync(getConfigFile(), "utf-8");
+  return JSON.parse(raw);
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(getConfigFile(), JSON.stringify(config, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function getActiveProfile() {
+  const config = loadConfig();
+  if (!config.activeProfile || !config.profiles[config.activeProfile]) {
+    return null;
+  }
+  return config.profiles[config.activeProfile];
+}
+function setActiveProfile(name) {
+  const config = loadConfig();
+  if (!config.profiles[name]) {
+    throw new Error(`Profile "${name}" does not exist`);
+  }
+  config.activeProfile = name;
+  saveConfig(config);
+}
+function addProfile(profile) {
+  const config = loadConfig();
+  config.profiles[profile.name] = profile;
+  if (!config.activeProfile) {
+    config.activeProfile = profile.name;
+  }
+  saveConfig(config);
+}
+function removeProfile(name) {
+  const config = loadConfig();
+  if (!config.profiles[name]) {
+    throw new Error(`Profile "${name}" does not exist`);
+  }
+  delete config.profiles[name];
+  if (config.activeProfile === name) {
+    const remaining = Object.keys(config.profiles);
+    config.activeProfile = remaining.length > 0 ? remaining[0] : "";
+  }
+  saveConfig(config);
+}
+function updateProfile(name, updates) {
+  const config = loadConfig();
+  if (!config.profiles[name]) {
+    throw new Error(`Profile "${name}" does not exist`);
+  }
+  config.profiles[name] = { ...config.profiles[name], ...updates };
+  saveConfig(config);
+}
+function listProfiles() {
+  const config = loadConfig();
+  return {
+    profiles: Object.values(config.profiles),
+    active: config.activeProfile
+  };
+}
+
+// src/client.ts
+var MetabaseClient = class {
+  domain;
+  sessionToken;
+  apiKey;
+  profile;
+  constructor(profile) {
+    this.profile = profile;
+    this.domain = profile.domain.replace(/\/+$/, "");
+    if (profile.auth.method === "session") {
+      this.sessionToken = profile.auth.sessionToken;
+    } else {
+      this.apiKey = profile.auth.apiKey;
+    }
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["X-Api-Key"] = this.apiKey;
+    } else if (this.sessionToken) {
+      headers["X-Metabase-Session"] = this.sessionToken;
+    }
+    return headers;
+  }
+  async request(method, path2, body, params) {
+    let url = `${this.domain}${path2}`;
+    if (params) {
+      const qs = new URLSearchParams(params).toString();
+      url += `?${qs}`;
+    }
+    const res = await fetch(url, {
+      method,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (res.status === 401 && this.profile.auth.method === "session") {
+      await this.login();
+      const retryRes = await fetch(url, {
+        method,
+        headers: this.getHeaders(),
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (!retryRes.ok) {
+        const err = await retryRes.text();
+        throw new Error(`${retryRes.status} ${retryRes.statusText}: ${err}`);
+      }
+      const retryText = await retryRes.text();
+      if (!retryText) return void 0;
+      return JSON.parse(retryText);
+    }
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`${res.status} ${res.statusText}: ${err}`);
+    }
+    const text = await res.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  async get(path2, params) {
+    return this.request("GET", path2, void 0, params);
+  }
+  async post(path2, body) {
+    return this.request("POST", path2, body);
+  }
+  async put(path2, body) {
+    return this.request("PUT", path2, body);
+  }
+  async delete(path2) {
+    return this.request("DELETE", path2);
+  }
+  async requestFormExport(path2, fields) {
+    const url = `${this.domain}${path2}`;
+    const headers = {};
+    if (this.apiKey) {
+      headers["X-Api-Key"] = this.apiKey;
+    } else if (this.sessionToken) {
+      headers["X-Metabase-Session"] = this.sessionToken;
+    }
+    const body = new URLSearchParams(fields);
+    const res = await fetch(url, { method: "POST", headers, body });
+    if (res.status === 401 && this.profile.auth.method === "session") {
+      await this.login();
+      if (this.sessionToken) {
+        headers["X-Metabase-Session"] = this.sessionToken;
+      }
+      return fetch(url, { method: "POST", headers, body: new URLSearchParams(fields) });
+    }
+    return res;
+  }
+  async requestRaw(method, path2, body) {
+    const url = `${this.domain}${path2}`;
+    const res = await fetch(url, {
+      method,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (res.status === 401 && this.profile.auth.method === "session") {
+      await this.login();
+      return fetch(url, {
+        method,
+        headers: this.getHeaders(),
+        body: body ? JSON.stringify(body) : void 0
+      });
+    }
+    return res;
+  }
+  async login() {
+    const auth = this.profile.auth;
+    const res = await fetch(`${this.domain}/api/session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username: auth.email, password: auth.password })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Login failed: ${res.status} ${err}`);
+    }
+    const session = await res.json();
+    this.sessionToken = session.id;
+    updateProfile(this.profile.name, {
+      auth: { ...auth, sessionToken: session.id }
+    });
+    const user = await this.get("/api/user/current");
+    const cachedUser = {
+      id: user.id,
+      email: user.email,
+      first_name: user.first_name,
+      last_name: user.last_name,
+      is_superuser: user.is_superuser
+    };
+    updateProfile(this.profile.name, { user: cachedUser });
+    this.profile.user = cachedUser;
+    return session;
+  }
+  async logout() {
+    await this.delete("/api/session");
+    this.sessionToken = void 0;
+    if (this.profile.auth.method === "session") {
+      updateProfile(this.profile.name, {
+        auth: { ...this.profile.auth, sessionToken: void 0 }
+      });
+    }
+  }
+  async ensureAuthenticated() {
+    if (this.apiKey) return;
+    if (!this.sessionToken) {
+      await this.login();
+    }
+  }
+  getProfile() {
+    return this.profile;
+  }
+  getUserId() {
+    return this.profile.user?.id ?? null;
+  }
+};
+
+// src/safety/guard.ts
+var SafetyGuard = class {
+  client;
+  unsafe;
+  constructor(client, unsafe = false) {
+    this.client = client;
+    this.unsafe = unsafe;
+  }
+  async checkOwnership(entityType, entityId) {
+    const pathMap = {
+      card: `/api/card/${entityId}`,
+      dashboard: `/api/dashboard/${entityId}`,
+      snippet: `/api/native-query-snippet/${entityId}`,
+      collection: `/api/collection/${entityId}`
+    };
+    const path2 = pathMap[entityType];
+    if (!path2) {
+      throw new Error(`Unknown entity type: ${entityType}`);
+    }
+    const entity = await this.client.get(path2);
+    const userId = this.client.getUserId();
+    if (userId === null) {
+      throw new Error("No cached user ID. Run 'metabase-cli login' or 'metabase-cli whoami --refresh' first.");
+    }
+    return {
+      owned: entity.creator_id === userId,
+      creatorId: entity.creator_id
+    };
+  }
+  async guard(entityType, entityId, action, fn) {
+    if (this.unsafe) {
+      return fn();
+    }
+    const { owned, creatorId } = await this.checkOwnership(entityType, entityId);
+    if (!owned) {
+      const userId = this.client.getUserId();
+      throw new Error(
+        `Safe mode: Cannot ${action} ${entityType} #${entityId} \u2014 owned by user #${creatorId}, you are user #${userId}. Use --unsafe to bypass.`
+      );
+    }
+    return fn();
+  }
+};
+
+// src/api/session.ts
+var SessionApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getCurrentUser() {
+    return this.client.get("/api/user/current");
+  }
+  async getSessionProperties() {
+    return this.client.get("/api/session/properties");
+  }
+};
+
+// src/utils/export.ts
+function checkExportError(buf, format) {
+  if (format !== "json" && buf.length > 0 && buf[0] === 123) {
+    try {
+      const parsed = JSON.parse(buf.toString("utf-8"));
+      if (parsed.status === "failed" || parsed.error) {
+        throw new Error(`Query failed: ${parsed.error || "unknown error"}`);
+      }
+    } catch (e) {
+      if (e.message.startsWith("Query failed:")) throw e;
+    }
+  }
+}
+
+// src/api/dataset.ts
+var DatasetApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async query(datasetQuery) {
+    return this.client.post("/api/dataset", datasetQuery);
+  }
+  async queryNative(database, sql, templateTags) {
+    return this.query({
+      type: "native",
+      database,
+      native: {
+        query: sql,
+        "template-tags": templateTags ?? {}
+      }
+    });
+  }
+  async export(datasetQuery, format) {
+    const res = await this.client.requestRaw(
+      "POST",
+      `/api/dataset/${format}`,
+      datasetQuery
+    );
+    if (!res.ok) {
+      throw new Error(`Export failed: ${res.status} ${await res.text()}`);
+    }
+    return res.text();
+  }
+  async exportBinary(datasetQuery, format) {
+    const res = await this.client.requestFormExport(
+      `/api/dataset/${format}`,
+      { query: JSON.stringify(datasetQuery) }
+    );
+    if (!res.ok) {
+      throw new Error(`Export failed: ${res.status} ${await res.text()}`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    checkExportError(buf, format);
+    return buf;
+  }
+};
+
+// src/api/card.ts
+var CardApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get("/api/card", params);
+  }
+  async get(id) {
+    return this.client.get(`/api/card/${id}`);
+  }
+  async create(params) {
+    return this.client.post("/api/card", params);
+  }
+  async update(id, params) {
+    return this.client.put(`/api/card/${id}`, params);
+  }
+  async delete(id) {
+    await this.client.delete(`/api/card/${id}`);
+  }
+  async copy(id, overrides) {
+    return this.client.post(`/api/card/${id}/copy`, overrides);
+  }
+  async query(id, parameters) {
+    return this.client.post(`/api/card/${id}/query`, {
+      parameters: parameters ?? []
+    });
+  }
+  async queryExport(id, format, parameters) {
+    const res = await this.client.requestRaw(
+      "POST",
+      `/api/card/${id}/query/${format}`,
+      { parameters: parameters ?? [] }
+    );
+    if (!res.ok) {
+      throw new Error(`Export failed: ${res.status} ${await res.text()}`);
+    }
+    return res.text();
+  }
+  async queryExportBinary(id, format, parameters) {
+    const fields = {};
+    if (parameters && parameters.length > 0) {
+      fields.parameters = JSON.stringify(parameters);
+    }
+    const res = await this.client.requestFormExport(
+      `/api/card/${id}/query/${format}`,
+      fields
+    );
+    if (!res.ok) {
+      throw new Error(`Export failed: ${res.status} ${await res.text()}`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    checkExportError(buf, format);
+    return buf;
+  }
+};
+
+// src/api/dashboard.ts
+var DashboardApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get("/api/dashboard", params);
+  }
+  async get(id) {
+    return this.client.get(`/api/dashboard/${id}`);
+  }
+  async create(params) {
+    return this.client.post("/api/dashboard", params);
+  }
+  async update(id, params) {
+    return this.client.put(`/api/dashboard/${id}`, params);
+  }
+  async delete(id) {
+    await this.client.delete(`/api/dashboard/${id}`);
+  }
+  async copy(id, overrides) {
+    return this.client.post(`/api/dashboard/${id}/copy`, overrides);
+  }
+};
+
+// src/api/collection.ts
+var CollectionApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.get("/api/collection");
+  }
+  async tree() {
+    return this.client.get("/api/collection/tree");
+  }
+  async get(id) {
+    return this.client.get(`/api/collection/${id}`);
+  }
+  async items(id, params) {
+    return this.client.get(`/api/collection/${id}/items`, params);
+  }
+  async create(params) {
+    return this.client.post("/api/collection", params);
+  }
+  async update(id, params) {
+    return this.client.put(`/api/collection/${id}`, params);
+  }
+};
+
+// src/api/database.ts
+var DatabaseApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.get("/api/database");
+  }
+  async get(id) {
+    return this.client.get(`/api/database/${id}`);
+  }
+  async metadata(id) {
+    return this.client.get(`/api/database/${id}/metadata`);
+  }
+  async schemas(id) {
+    return this.client.get(`/api/database/${id}/schemas`);
+  }
+  async tablesInSchema(id, schema) {
+    return this.client.get(
+      `/api/database/${id}/schema/${encodeURIComponent(schema)}`
+    );
+  }
+};
+
+// src/api/table.ts
+var TableApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(id) {
+    return this.client.get(`/api/table/${id}`);
+  }
+  async queryMetadata(id) {
+    return this.client.get(`/api/table/${id}/query_metadata`);
+  }
+  async foreignKeys(id) {
+    return this.client.get(`/api/table/${id}/fks`);
+  }
+};
+
+// src/api/field.ts
+var FieldApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(id) {
+    return this.client.get(`/api/field/${id}`);
+  }
+  async values(id) {
+    return this.client.get(`/api/field/${id}/values`);
+  }
+};
+
+// src/api/snippet.ts
+var SnippetApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get("/api/native-query-snippet", params);
+  }
+  async get(id) {
+    return this.client.get(`/api/native-query-snippet/${id}`);
+  }
+  async create(params) {
+    return this.client.post("/api/native-query-snippet", params);
+  }
+  async update(id, params) {
+    return this.client.put(`/api/native-query-snippet/${id}`, params);
+  }
+};
+
+// src/api/search.ts
+var SearchApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(query, params) {
+    const qs = { q: query };
+    if (params?.models?.length) {
+      qs.models = params.models.join(",");
+    }
+    if (params?.limit !== void 0) qs.limit = String(params.limit);
+    if (params?.offset !== void 0) qs.offset = String(params.offset);
+    return this.client.get("/api/search", qs);
+  }
+};
+
+// src/api/user.ts
+var UserApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get("/api/user", params);
+  }
+  async get(id) {
+    return this.client.get(`/api/user/${id}`);
+  }
+  async current() {
+    return this.client.get("/api/user/current");
+  }
+};
+
+// src/utils/output.ts
+var import_cli_table3 = __toESM(require("cli-table3"));
+function formatDatasetResponse(dataset, format = "table", columns) {
+  const cols = dataset.data.cols;
+  const rows = dataset.data.rows;
+  let colIndices;
+  if (columns?.length) {
+    colIndices = columns.map((name) => {
+      const idx = cols.findIndex(
+        (c) => c.name === name || c.display_name === name
+      );
+      if (idx === -1) throw new Error(`Column "${name}" not found`);
+      return idx;
+    });
+  } else {
+    colIndices = cols.map((_, i) => i);
+  }
+  const filteredCols = colIndices.map((i) => cols[i]);
+  const filteredRows = rows.map((row) => colIndices.map((i) => row[i]));
+  switch (format) {
+    case "json":
+      return JSON.stringify(
+        filteredRows.map(
+          (row) => Object.fromEntries(
+            filteredCols.map((col, i) => [col.name, row[i]])
+          )
+        ),
+        null,
+        2
+      );
+    case "csv":
+      return formatDelimited(filteredCols, filteredRows, ",");
+    case "tsv":
+      return formatDelimited(filteredCols, filteredRows, "	");
+    case "table":
+    default:
+      return formatTable(filteredCols, filteredRows);
+  }
+}
+function formatDelimited(cols, rows, delimiter) {
+  const header = cols.map((c) => escapeCsvField(String(c.name), delimiter)).join(delimiter);
+  const body = rows.map(
+    (row) => row.map((cell) => escapeCsvField(formatCell(cell), delimiter)).join(delimiter)
+  );
+  return [header, ...body].join("\n");
+}
+function escapeCsvField(value, delimiter) {
+  if (value.includes(delimiter) || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function formatTable(cols, rows) {
+  const table = new import_cli_table3.default({
+    head: cols.map((c) => c.display_name),
+    style: { head: ["cyan"] }
+  });
+  for (const row of rows) {
+    table.push(row.map((cell) => formatCell(cell)));
+  }
+  return table.toString();
+}
+function formatCell(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatEntityTable(items, columns) {
+  const table = new import_cli_table3.default({
+    head: columns.map((c) => c.header),
+    style: { head: ["cyan"] }
+  });
+  for (const item of items) {
+    table.push(columns.map((c) => formatCell(item[c.key])));
+  }
+  return table.toString();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CardApi,
+  CollectionApi,
+  DashboardApi,
+  DatabaseApi,
+  DatasetApi,
+  FieldApi,
+  MetabaseClient,
+  SafetyGuard,
+  SearchApi,
+  SessionApi,
+  SnippetApi,
+  TableApi,
+  UserApi,
+  addProfile,
+  formatDatasetResponse,
+  formatEntityTable,
+  formatJson,
+  getActiveProfile,
+  listProfiles,
+  loadConfig,
+  removeProfile,
+  saveConfig,
+  setActiveProfile,
+  updateProfile
+});
+//# sourceMappingURL=index.js.map