datagrok-tools 6.1.9 → 6.1.11

package/bin/utils/node-dapi.js

@@ -0,0 +1,582 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodeUsersDataSource = exports.NodeTablesDataSource = exports.NodeSharesDataSource = exports.NodeHttpDataSource = exports.NodeGroupsDataSource = exports.NodeFuncsDataSource = exports.NodeFilesDataSource = exports.NodeDapi = exports.NodeConnectionsDataSource = exports.NodeApiClient = void 0;
+exports.ensureBodyId = ensureBodyId;
+var _crypto = require("crypto");
+/// Docs: [Grok Dapi](/docs/plans/grok-dapi/)
+
+function ensureBodyId(body) {
+  if (body && typeof body === 'object' && !body.id) body.id = (0, _crypto.randomUUID)();
+  return body;
+}
+class NodeApiClient {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  static async login(baseUrl, devKey) {
+    const res = await fetch(`${baseUrl}/users/login/dev/${devKey}`, {
+      method: 'POST'
+    });
+    const json = await res.json();
+    if (!json.token) throw new Error('Login failed. Check your developer key.');
+    return new NodeApiClient(baseUrl, json.token);
+  }
+  async request(method, path, body, headers) {
+    const url = `${this.baseUrl}${path}`;
+    const opts = {
+      method,
+      headers: {
+        'Authorization': this.token,
+        'Content-Type': 'application/json',
+        ...headers
+      }
+    };
+    if (body !== undefined) opts.body = JSON.stringify(body);
+    const res = await fetch(url, opts);
+    if (!res.ok) {
+      // Read as text first to avoid "Body has already been read" when JSON.parse fails
+      const rawText = await res.text();
+      let errBody;
+      try {
+        errBody = JSON.parse(rawText);
+      } catch {
+        errBody = {
+          error: rawText || `HTTP ${res.status}`
+        };
+      }
+      const err = {
+        error: errBody?.message ?? errBody?.error ?? `HTTP ${res.status}`,
+        source: errBody?.source ?? 'Server',
+        errorCode: errBody?.errorCode ?? res.status,
+        stackTrace: errBody?.stackTrace
+      };
+      throw Object.assign(new Error(err.error), {
+        apiError: err
+      });
+    }
+    if (res.status === 204 || res.headers.get('content-length') === '0') return null;
+    const ct = res.headers.get('content-type') ?? '';
+    if (ct.includes('application/json')) return res.json();
+    return res.text();
+  }
+  get(path) {
+    return this.request('GET', path);
+  }
+  post(path, body) {
+    return this.request('POST', path, body);
+  }
+  del(path) {
+    return this.request('DELETE', path);
+  }
+
+  /**
+   * POST raw bytes — used for file/table uploads where the body must be the content
+   * itself, not JSON. Defaults to `application/octet-stream`; pass `text/csv` (or
+   * similar) when the server demands a specific content type.
+   */
+  async putBytes(path, bytes, contentType = 'application/octet-stream') {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: 'POST',
+      headers: {
+        'Authorization': this.token,
+        'Content-Type': contentType
+      },
+      body: bytes
+    });
+    if (!res.ok) {
+      const rawText = await res.text();
+      let errBody;
+      try {
+        errBody = JSON.parse(rawText);
+      } catch {
+        errBody = {
+          error: rawText || `HTTP ${res.status}`
+        };
+      }
+      const err = {
+        error: errBody?.message ?? errBody?.error ?? `HTTP ${res.status}`,
+        source: errBody?.source ?? 'Server',
+        errorCode: errBody?.errorCode ?? res.status,
+        stackTrace: errBody?.stackTrace
+      };
+      throw Object.assign(new Error(err.error), {
+        apiError: err
+      });
+    }
+    const ct = res.headers.get('content-type') ?? '';
+    if (ct.includes('application/json')) return res.json();
+    return res.text();
+  }
+}
+exports.NodeApiClient = NodeApiClient;
+function buildQuery(params) {
+  const entries = Object.entries(params).filter(([, v]) => v !== undefined && v !== null && v !== '');
+  if (!entries.length) return '';
+  return '?' + entries.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join('&');
+}
+class NodeHttpDataSource {
+  _filter = '';
+  _limit = 50;
+  _page = 0;
+  _order = '';
+  constructor(client, path) {
+    this.client = client;
+    this.path = path;
+  }
+  filter(w) {
+    this._filter = w;
+    return this;
+  }
+  by(n) {
+    this._limit = n;
+    return this;
+  }
+  page(n) {
+    this._page = n;
+    return this;
+  }
+  order(field, desc = false) {
+    this._order = desc ? `-${field}` : field;
+    return this;
+  }
+  async list() {
+    const q = buildQuery({
+      text: this._filter || undefined,
+      limit: this._limit,
+      page: this._page || undefined,
+      order: this._order || undefined
+    });
+    return this.client.get(`/public/v1/${this.path}${q}`);
+  }
+  async find(id) {
+    return this.client.get(`/public/v1/${this.path}/${encodeURIComponent(id.replace(':', '.'))}`);
+  }
+  async count() {
+    const q = buildQuery({
+      text: this._filter || undefined
+    });
+    const res = await this.client.get(`/public/v1/${this.path}/count${q}`);
+    return typeof res === 'number' ? res : res?.count ?? 0;
+  }
+  async delete(idOrEntity) {
+    const id = typeof idOrEntity === 'string' ? idOrEntity : idOrEntity?.id ?? '';
+    await this.client.del(`/public/v1/${this.path}/${encodeURIComponent(id)}`);
+  }
+}
+exports.NodeHttpDataSource = NodeHttpDataSource;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+class NodeGroupsDataSource extends NodeHttpDataSource {
+  constructor(client) {
+    super(client, 'groups');
+  }
+  async save(group, saveRelations = false) {
+    const q = buildQuery({
+      saveRelations: saveRelations ? 'true' : undefined
+    });
+    return this.client.post(`/public/v1/groups${q}`, ensureBodyId(group));
+  }
+  async lookup(name) {
+    const q = buildQuery({
+      query: name
+    });
+    return this.client.get(`/public/v1/groups/lookup${q}`);
+  }
+  async resolve(idOrName, opts = {}) {
+    if (UUID_RE.test(idOrName)) return this.find(idOrName);
+    const matches = await this.lookup(idOrName);
+    let candidates = matches;
+    if (opts.personalOnly) candidates = matches.filter(g => g?.personal === true);
+    if (!candidates.length) {
+      const suffix = opts.personalOnly ? ' (personal)' : '';
+      throw new Error(`No group matching '${idOrName}'${suffix}`);
+    }
+    if (candidates.length > 1) {
+      const list = candidates.map(g => `  ${g.id}  ${g.friendlyName ?? g.name ?? ''}`).join('\n');
+      throw new Error(`Multiple groups match '${idOrName}':\n${list}\nUse the ID to disambiguate.`);
+    }
+    return candidates[0];
+  }
+  async addMembers(group, members, isAdmin = false, personalOnly = false) {
+    // Always fetch via find() so parent.children comes back expanded; lookup() returns a
+    // pruned projection and replacing that empty list on save would drop existing members.
+    const resolved = await this.resolve(group);
+    const parent = await this.find(resolved.id);
+    const children = Array.isArray(parent.children) ? parent.children : [];
+    const results = [];
+    let mutated = false;
+    for (const m of members) {
+      let child;
+      try {
+        child = await this.resolve(m, {
+          personalOnly
+        });
+      } catch (err) {
+        results.push({
+          member: m,
+          status: 'error',
+          error: err?.message ?? String(err)
+        });
+        continue;
+      }
+      const existing = children.find(r => r?.child?.id === child.id);
+      if (existing) {
+        // Server returns isAdmin as null/undefined for non-admin relations; normalize
+        // the comparison so re-runs report `noop` instead of `updated`.
+        if ((existing.isAdmin ?? false) === isAdmin) {
+          results.push({
+            member: m,
+            status: 'noop'
+          });
+        } else {
+          existing.isAdmin = isAdmin;
+          mutated = true;
+          results.push({
+            member: m,
+            status: 'updated'
+          });
+        }
+      } else {
+        // Each GroupRelation row needs a non-null id; the server rejects the save otherwise.
+        children.push({
+          id: (0, _crypto.randomUUID)(),
+          parent: {
+            id: parent.id
+          },
+          child: {
+            id: child.id
+          },
+          isAdmin
+        });
+        mutated = true;
+        results.push({
+          member: m,
+          status: 'added'
+        });
+      }
+    }
+    if (mutated) {
+      parent.children = children;
+      await this.save(parent, true);
+    }
+    return results;
+  }
+  async removeMembers(group, members, personalOnly = false) {
+    const resolved = await this.resolve(group);
+    const parent = await this.find(resolved.id);
+    const results = [];
+    const children = Array.isArray(parent.children) ? parent.children : [];
+    let mutated = false;
+    for (const m of members) {
+      let child;
+      try {
+        child = await this.resolve(m, {
+          personalOnly
+        });
+      } catch (err) {
+        results.push({
+          member: m,
+          status: 'error',
+          error: err?.message ?? String(err)
+        });
+        continue;
+      }
+      const idx = children.findIndex(r => r?.child?.id === child.id);
+      if (idx === -1) {
+        results.push({
+          member: m,
+          status: 'not-member'
+        });
+      } else {
+        children.splice(idx, 1);
+        mutated = true;
+        results.push({
+          member: m,
+          status: 'removed'
+        });
+      }
+    }
+    if (mutated) {
+      parent.children = children;
+      await this.save(parent, true);
+    }
+    return results;
+  }
+  async getMembers(group, admin) {
+    const parent = await this.resolve(group);
+    const q = buildQuery({
+      admin: admin === undefined ? undefined : String(admin)
+    });
+    return this.client.get(`/public/v1/groups/${encodeURIComponent(parent.id)}/members${q}`);
+  }
+  async getMemberships(group, admin) {
+    const parent = await this.resolve(group);
+    const q = buildQuery({
+      admin: admin === undefined ? undefined : String(admin)
+    });
+    return this.client.get(`/public/v1/groups/${encodeURIComponent(parent.id)}/memberships${q}`);
+  }
+}
+exports.NodeGroupsDataSource = NodeGroupsDataSource;
+class NodeSharesDataSource {
+  constructor(client) {
+    this.client = client;
+  }
+  async share(entity, groups, access = 'View') {
+    const name = encodeURIComponent(entity.replace(':', '.'));
+    const q = buildQuery({
+      groups,
+      access
+    });
+    return this.client.post(`/public/v1/entities/${name}/shares${q}`);
+  }
+  async list(entityId) {
+    const q = buildQuery({
+      entityId
+    });
+    return this.client.get(`/privileges/permissions${q}`);
+  }
+}
+exports.NodeSharesDataSource = NodeSharesDataSource;
+class NodeUsersDataSource extends NodeHttpDataSource {
+  constructor(client) {
+    super(client, 'users');
+  }
+  async save(user) {
+    return this.client.post('/public/v1/users', ensureBodyId(user));
+  }
+  async block(user) {
+    await this.client.post('/public/v1/users/block', user);
+  }
+  async unblock(user) {
+    await this.client.post('/public/v1/users/unblock', user);
+  }
+}
+exports.NodeUsersDataSource = NodeUsersDataSource;
+class NodeConnectionsDataSource extends NodeHttpDataSource {
+  constructor(client) {
+    super(client, 'connections');
+  }
+  async save(conn, saveCredentials = false) {
+    const q = buildQuery({
+      saveCredentials: saveCredentials ? 'true' : undefined
+    });
+    return this.client.post(`/public/v1/connections${q}`, conn);
+  }
+  async test(conn) {
+    const result = await this.client.post(`/public/v1/connections/test`, conn);
+    const text = typeof result === 'string' ? result.replace(/^"|"$/g, '') : String(result ?? '');
+    if (text !== 'ok') throw new Error(text || 'Connection test failed');
+  }
+}
+exports.NodeConnectionsDataSource = NodeConnectionsDataSource;
+class NodeFuncsDataSource extends NodeHttpDataSource {
+  async run(name, params) {
+    const normalizedName = name.replace(':', '.');
+    const result = await this.client.post(`/public/v1/functions/${encodeURIComponent(normalizedName)}/call`, params ?? {});
+    // Datagrok returns HTTP 200 with an ApiError body when the function doesn't exist
+    const parsed = typeof result === 'string' ? tryParseJson(result) : result;
+    if (parsed?.['#type'] === 'ApiError') {
+      const err = {
+        error: parsed.message ?? 'Function call failed',
+        errorCode: parsed.errorCode,
+        stackTrace: parsed.stackTrace
+      };
+      throw Object.assign(new Error(err.error), {
+        apiError: err
+      });
+    }
+    return result;
+  }
+}
+exports.NodeFuncsDataSource = NodeFuncsDataSource;
+function tryParseJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+class NodeFilesDataSource {
+  constructor(client) {
+    this.client = client;
+  }
+
+  /**
+   * Split a user-facing file path into {connector, path}.
+   *
+   * Input format: `<connector>/<file-path>` where `<connector>` is the connection's
+   * full name — including namespace — e.g. `System:DemoFiles/smiles_1M.csv`.
+   * The connector can contain colons (the namespace separator); the file path
+   * starts after the first `/`. Colons in the connector segment are converted
+   * to `.` so it forms a single URL path segment (the Dart server reverses
+   * this with `replaceAll('.', ':')`).
+   */
+  splitPath(filePath) {
+    const slashIdx = filePath.indexOf('/');
+    if (slashIdx === -1) return {
+      connector: filePath.replace(/:/g, '.'),
+      path: ''
+    };
+    const connector = filePath.slice(0, slashIdx).replace(/:/g, '.');
+    const path = filePath.slice(slashIdx + 1);
+    return {
+      connector,
+      path
+    };
+  }
+  async list(filePath, recursive = false) {
+    const {
+      connector,
+      path
+    } = this.splitPath(filePath);
+    const q = buildQuery({
+      recursive: recursive ? 'true' : undefined
+    });
+    const seg = path ? `${connector}/${path}` : connector;
+    return this.client.get(`/public/v1/files/${seg}${q}`);
+  }
+  async get(filePath) {
+    const {
+      connector,
+      path
+    } = this.splitPath(filePath);
+    const seg = path ? `${connector}/${path}` : connector;
+    return this.client.get(`/public/v1/files/${seg}`);
+  }
+  async delete(filePath) {
+    const {
+      connector,
+      path
+    } = this.splitPath(filePath);
+    const seg = path ? `${connector}/${path}` : connector;
+    await this.client.del(`/public/v1/files/${seg}`);
+  }
+
+  /**
+   * Upload a local file to a Datagrok file share.
+   * Streams raw bytes to POST `/public/v1/files/<connector>/<path>` — no base64,
+   * no JSON wrapping — so it handles large files without blowing up memory.
+   */
+  async put(localPath, remotePath) {
+    const fs = require('fs');
+    const {
+      connector,
+      path
+    } = this.splitPath(remotePath);
+    if (!path) throw new Error(`Remote path must include a file name after the connector: got '${remotePath}'`);
+    const bytes = fs.readFileSync(localPath);
+    const res = await this.client.putBytes(`/public/v1/files/${connector}/${path}`, bytes);
+    return {
+      path: remotePath,
+      size: bytes.length,
+      response: res
+    };
+  }
+}
+exports.NodeFilesDataSource = NodeFilesDataSource;
+class NodeTablesDataSource {
+  constructor(client) {
+    this.client = client;
+  }
+
+  /** GET /public/v1/tables/{name} — returns CSV text. Name accepts UUID or `namespace:name`. */
+  async download(name) {
+    const seg = encodeURIComponent(name.replace(/:/g, '.'));
+    const result = await this.client.get(`/public/v1/tables/${seg}`);
+    // Datagrok returns HTTP 200 + ApiError JSON when the table isn't found.
+    const parsed = typeof result === 'string' ? tryParseJson(result) : result;
+    if (parsed && typeof parsed === 'object' && parsed['#type'] === 'ApiError') {
+      const err = {
+        error: parsed.message ?? 'Table download failed',
+        errorCode: parsed.errorCode,
+        stackTrace: parsed.stackTrace
+      };
+      throw Object.assign(new Error(err.error), {
+        apiError: err
+      });
+    }
+    return result;
+  }
+
+  /** POST /public/v1/tables/{name} with raw CSV bytes. Returns `{ID, Grok name, Markup, URL}`. */
+  async upload(name, localPath) {
+    const fs = require('fs');
+    const bytes = fs.readFileSync(localPath);
+    const seg = encodeURIComponent(name.replace(/:/g, '.'));
+    return this.client.putBytes(`/public/v1/tables/${seg}`, bytes, 'text/csv');
+  }
+}
+exports.NodeTablesDataSource = NodeTablesDataSource;
+class NodeDapi {
+  constructor(client) {
+    this.client = client;
+  }
+  get users() {
+    return new NodeUsersDataSource(this.client);
+  }
+  get groups() {
+    return new NodeGroupsDataSource(this.client);
+  }
+  get functions() {
+    return new NodeFuncsDataSource(this.client, 'functions');
+  }
+  get connections() {
+    return new NodeConnectionsDataSource(this.client);
+  }
+  get queries() {
+    return new NodeHttpDataSource(this.client, 'queries');
+  }
+  get scripts() {
+    return new NodeHttpDataSource(this.client, 'scripts');
+  }
+  get packages() {
+    return new NodeHttpDataSource(this.client, 'packages');
+  }
+  get reports() {
+    return new NodeHttpDataSource(this.client, 'reports');
+  }
+  get files() {
+    return new NodeFilesDataSource(this.client);
+  }
+  get shares() {
+    return new NodeSharesDataSource(this.client);
+  }
+  get tables() {
+    return new NodeTablesDataSource(this.client);
+  }
+  async raw(method, path, body) {
+    // Raw paths are relative to server root (e.g. /api/users/current).
+    // Strip the trailing /api from baseUrl to avoid double prefix.
+    const serverRoot = this.client.baseUrl.replace(/\/api\/?$/, '');
+    const url = `${serverRoot}${path}`;
+    const opts = {
+      method: method.toUpperCase(),
+      headers: {
+        'Authorization': this.client.token,
+        'Content-Type': 'application/json'
+      }
+    };
+    if (body !== undefined) opts.body = JSON.stringify(body);
+    const res = await fetch(url, opts);
+    const ct = res.headers.get('content-type') ?? '';
+    if (ct.includes('application/json')) return res.json();
+    return res.text();
+  }
+  async batch(request) {
+    return this.client.post('/public/v1/batch', request);
+  }
+  async describe(entityType) {
+    try {
+      return await this.client.get(`/public/v1/entity-types/${encodeURIComponent(entityType)}`);
+    } catch {
+      return await this.client.get(`/entities/types${buildQuery({
+        name: entityType
+      })}`);
+    }
+  }
+}
+exports.NodeDapi = NodeDapi;

package/bin/utils/server-client.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createClient = createClient;
+var _nodeDapi = require("./node-dapi");
+var _testUtils = require("./test-utils");
+async function createClient(hostArg) {
+  const {
+    url,
+    key
+  } = (0, _testUtils.getDevKey)(hostArg ?? '');
+  return _nodeDapi.NodeApiClient.login(url, key);
+}