datagrok-tools 6.1.8 → 6.1.10

package/bin/__tests__/node-dapi.users.test.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _nodeDapi = require("../utils/node-dapi");
+function makeMock(responder) {
+  const calls = [];
+  const client = {
+    async request(method, path, body) {
+      calls.push({
+        method,
+        path,
+        body
+      });
+      return responder(method, path, body);
+    },
+    get(path) {
+      return this.request('GET', path);
+    },
+    post(path, body) {
+      return this.request('POST', path, body);
+    },
+    del(path) {
+      return this.request('DELETE', path);
+    }
+  };
+  return {
+    client,
+    calls
+  };
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+(0, _vitest.describe)('ensureBodyId', () => {
+  (0, _vitest.it)('assigns a UUID when id is missing', () => {
+    const body = {
+      name: 'alice'
+    };
+    (0, _nodeDapi.ensureBodyId)(body);
+    (0, _vitest.expect)(body.id).toMatch(UUID_RE);
+  });
+  (0, _vitest.it)('preserves an existing id', () => {
+    const body = {
+      id: 'preset-id',
+      name: 'alice'
+    };
+    (0, _nodeDapi.ensureBodyId)(body);
+    (0, _vitest.expect)(body.id).toBe('preset-id');
+  });
+});
+(0, _vitest.describe)('NodeUsersDataSource.save', () => {
+  (0, _vitest.it)('POSTs to /public/v1/users and generates an id when missing', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/users') return {
+        ...body,
+        name: 'alice'
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeUsersDataSource(client);
+    const result = await ds.save({
+      firstName: 'Alice',
+      lastName: 'A',
+      email: 'a@x.com'
+    });
+    (0, _vitest.expect)(calls[0].path).toBe('/public/v1/users');
+    (0, _vitest.expect)(calls[0].body.id).toMatch(UUID_RE);
+    (0, _vitest.expect)(result.name).toBe('alice');
+  });
+  (0, _vitest.it)('preserves an existing id in the body', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/users') return body;
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeUsersDataSource(client);
+    await ds.save({
+      id: 'existing-uuid',
+      firstName: 'Alice'
+    });
+    (0, _vitest.expect)(calls[0].body.id).toBe('existing-uuid');
+  });
+});

package/bin/__tests__/node-dapi.users.test.ts

@@ -0,0 +1,58 @@
+import {describe, it, expect} from 'vitest';
+import {NodeUsersDataSource, ensureBodyId} from '../utils/node-dapi';
+
+interface Call {method: string; path: string; body?: any}
+
+function makeMock(responder: (method: string, path: string, body?: any) => any) {
+  const calls: Call[] = [];
+  const client: any = {
+    async request(method: string, path: string, body?: any) {
+      calls.push({method, path, body});
+      return responder(method, path, body);
+    },
+    get(path: string) { return this.request('GET', path); },
+    post(path: string, body?: any) { return this.request('POST', path, body); },
+    del(path: string) { return this.request('DELETE', path); },
+  };
+  return {client, calls};
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+describe('ensureBodyId', () => {
+  it('assigns a UUID when id is missing', () => {
+    const body = {name: 'alice'};
+    ensureBodyId(body);
+    expect((body as any).id).toMatch(UUID_RE);
+  });
+
+  it('preserves an existing id', () => {
+    const body = {id: 'preset-id', name: 'alice'};
+    ensureBodyId(body);
+    expect(body.id).toBe('preset-id');
+  });
+});
+
+describe('NodeUsersDataSource.save', () => {
+  it('POSTs to /public/v1/users and generates an id when missing', async () => {
+    const {client, calls} = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/users') return {...body, name: 'alice'};
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new NodeUsersDataSource(client);
+    const result = await ds.save({firstName: 'Alice', lastName: 'A', email: 'a@x.com'});
+    expect(calls[0].path).toBe('/public/v1/users');
+    expect(calls[0].body.id).toMatch(UUID_RE);
+    expect(result.name).toBe('alice');
+  });
+
+  it('preserves an existing id in the body', async () => {
+    const {client, calls} = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/users') return body;
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new NodeUsersDataSource(client);
+    await ds.save({id: 'existing-uuid', firstName: 'Alice'});
+    expect(calls[0].body.id).toBe('existing-uuid');
+  });
+});

package/bin/__tests__/server-output.test.js

@@ -0,0 +1,171 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _serverOutput = require("../utils/server-output");
+(0, _vitest.describe)('cellStr', () => {
+  (0, _vitest.it)('returns empty string for null', () => {
+    (0, _vitest.expect)((0, _serverOutput.cellStr)(null)).toBe('');
+  });
+  (0, _vitest.it)('returns empty string for undefined', () => {
+    (0, _vitest.expect)((0, _serverOutput.cellStr)(undefined)).toBe('');
+  });
+  (0, _vitest.it)('returns the name property for objects with a name', () => {
+    (0, _vitest.expect)((0, _serverOutput.cellStr)({
+      name: 'Alice',
+      id: '1'
+    })).toBe('Alice');
+  });
+  (0, _vitest.it)('falls back to id when name is absent', () => {
+    (0, _vitest.expect)((0, _serverOutput.cellStr)({
+      id: 'abc-123'
+    })).toBe('abc-123');
+  });
+  (0, _vitest.it)('returns truncated JSON for objects with neither name nor id', () => {
+    const result = (0, _serverOutput.cellStr)({
+      foo: 'bar',
+      baz: 42
+    });
+    (0, _vitest.expect)(result).toBe('{"foo":"bar","baz":42}');
+    (0, _vitest.expect)(result.length).toBeLessThanOrEqual(40);
+  });
+  (0, _vitest.it)('truncates long JSON to 40 characters', () => {
+    const obj = {
+      key: 'a'.repeat(50)
+    };
+    (0, _vitest.expect)((0, _serverOutput.cellStr)(obj).length).toBe(40);
+  });
+  (0, _vitest.it)('converts a number to string', () => {
+    (0, _vitest.expect)((0, _serverOutput.cellStr)(123)).toBe('123');
+  });
+  (0, _vitest.it)('converts a boolean to string', () => {
+    (0, _vitest.expect)((0, _serverOutput.cellStr)(true)).toBe('true');
+    (0, _vitest.expect)((0, _serverOutput.cellStr)(false)).toBe('false');
+  });
+  (0, _vitest.it)('returns a plain string as-is', () => {
+    (0, _vitest.expect)((0, _serverOutput.cellStr)('hello')).toBe('hello');
+  });
+});
+(0, _vitest.describe)('csvCell', () => {
+  (0, _vitest.it)('returns the string unchanged when no special chars', () => {
+    (0, _vitest.expect)((0, _serverOutput.csvCell)('hello')).toBe('hello');
+  });
+  (0, _vitest.it)('wraps in quotes when the value contains a comma', () => {
+    (0, _vitest.expect)((0, _serverOutput.csvCell)('a,b')).toBe('"a,b"');
+  });
+  (0, _vitest.it)('wraps and escapes double quotes', () => {
+    (0, _vitest.expect)((0, _serverOutput.csvCell)('say "hi"')).toBe('"say ""hi"""');
+  });
+  (0, _vitest.it)('wraps in quotes when the value contains a newline', () => {
+    (0, _vitest.expect)((0, _serverOutput.csvCell)('line1\nline2')).toBe('"line1\nline2"');
+  });
+  (0, _vitest.it)('handles an empty string', () => {
+    (0, _vitest.expect)((0, _serverOutput.csvCell)('')).toBe('');
+  });
+});
+(0, _vitest.describe)('getKeys', () => {
+  (0, _vitest.it)('returns an empty array for an empty input', () => {
+    (0, _vitest.expect)((0, _serverOutput.getKeys)([])).toEqual([]);
+  });
+  (0, _vitest.it)('returns keys from a single object', () => {
+    (0, _vitest.expect)((0, _serverOutput.getKeys)([{
+      a: 1,
+      b: 2
+    }])).toEqual(['a', 'b']);
+  });
+  (0, _vitest.it)('unions keys across multiple objects', () => {
+    (0, _vitest.expect)((0, _serverOutput.getKeys)([{
+      a: 1
+    }, {
+      b: 2
+    }, {
+      a: 3,
+      c: 4
+    }])).toEqual(['a', 'b', 'c']);
+  });
+  (0, _vitest.it)('deduplicates keys', () => {
+    (0, _vitest.expect)((0, _serverOutput.getKeys)([{
+      a: 1,
+      b: 2
+    }, {
+      a: 3,
+      b: 4
+    }])).toEqual(['a', 'b']);
+  });
+  (0, _vitest.it)('preserves insertion order (first appearance wins)', () => {
+    (0, _vitest.expect)((0, _serverOutput.getKeys)([{
+      b: 1,
+      a: 2
+    }, {
+      a: 3,
+      c: 4
+    }])).toEqual(['b', 'a', 'c']);
+  });
+  (0, _vitest.it)('caps the result at 12 keys', () => {
+    const row = Object.fromEntries(Array.from({
+      length: 15
+    }, (_, i) => [`k${i}`, i]));
+    const keys = (0, _serverOutput.getKeys)([row]);
+    (0, _vitest.expect)(keys).toHaveLength(12);
+    (0, _vitest.expect)(keys).toEqual(Array.from({
+      length: 12
+    }, (_, i) => `k${i}`));
+  });
+});
+(0, _vitest.describe)('printBatchOutput', () => {
+  let logLines;
+  let errLines;
+  (0, _vitest.beforeEach)(() => {
+    logLines = [];
+    errLines = [];
+    _vitest.vi.spyOn(console, 'log').mockImplementation((...args) => logLines.push(args.join(' ')));
+    _vitest.vi.spyOn(process.stderr, 'write').mockImplementation(chunk => {
+      errLines.push(String(chunk));
+      return true;
+    });
+  });
+  (0, _vitest.afterEach)(() => {
+    _vitest.vi.restoreAllMocks();
+  });
+  (0, _vitest.it)('json: output is valid JSON equal to the full response', () => {
+    const resp = {
+      summary: {
+        total: 1,
+        succeeded: 1,
+        failed: 0,
+        partial: 0,
+        skipped: 0
+      },
+      results: [{
+        id: 'op0',
+        action: 'users.delete',
+        status: 'success'
+      }]
+    };
+    (0, _serverOutput.printBatchOutput)(resp, 'json');
+    (0, _vitest.expect)(JSON.parse(logLines[0])).toEqual(resp);
+  });
+  (0, _vitest.it)('table: failed operations are written to stderr as structured JSON', () => {
+    const resp = {
+      summary: {
+        total: 1,
+        succeeded: 0,
+        failed: 1,
+        partial: 0,
+        skipped: 0
+      },
+      results: [{
+        id: 'op0',
+        action: 'users.delete',
+        status: 'error',
+        error: {
+          error: 'Not found'
+        }
+      }]
+    };
+    (0, _serverOutput.printBatchOutput)(resp, 'table');
+    (0, _vitest.expect)(errLines.length).toBeGreaterThan(0);
+    const parsed = JSON.parse(errLines[0]);
+    (0, _vitest.expect)(parsed[0].id).toBe('op0');
+    (0, _vitest.expect)(parsed[0].error.error).toBe('Not found');
+  });
+});

package/bin/__tests__/server-output.test.ts

@@ -0,0 +1,133 @@
+import {describe, it, expect, vi, beforeEach, afterEach} from 'vitest';
+import {cellStr, csvCell, getKeys, printBatchOutput} from '../utils/server-output';
+import type {BatchResponse} from '../utils/node-dapi';
+
+describe('cellStr', () => {
+  it('returns empty string for null', () => {
+    expect(cellStr(null)).toBe('');
+  });
+
+  it('returns empty string for undefined', () => {
+    expect(cellStr(undefined)).toBe('');
+  });
+
+  it('returns the name property for objects with a name', () => {
+    expect(cellStr({name: 'Alice', id: '1'})).toBe('Alice');
+  });
+
+  it('falls back to id when name is absent', () => {
+    expect(cellStr({id: 'abc-123'})).toBe('abc-123');
+  });
+
+  it('returns truncated JSON for objects with neither name nor id', () => {
+    const result = cellStr({foo: 'bar', baz: 42});
+    expect(result).toBe('{"foo":"bar","baz":42}');
+    expect(result.length).toBeLessThanOrEqual(40);
+  });
+
+  it('truncates long JSON to 40 characters', () => {
+    const obj = {key: 'a'.repeat(50)};
+    expect(cellStr(obj).length).toBe(40);
+  });
+
+  it('converts a number to string', () => {
+    expect(cellStr(123)).toBe('123');
+  });
+
+  it('converts a boolean to string', () => {
+    expect(cellStr(true)).toBe('true');
+    expect(cellStr(false)).toBe('false');
+  });
+
+  it('returns a plain string as-is', () => {
+    expect(cellStr('hello')).toBe('hello');
+  });
+});
+
+describe('csvCell', () => {
+  it('returns the string unchanged when no special chars', () => {
+    expect(csvCell('hello')).toBe('hello');
+  });
+
+  it('wraps in quotes when the value contains a comma', () => {
+    expect(csvCell('a,b')).toBe('"a,b"');
+  });
+
+  it('wraps and escapes double quotes', () => {
+    expect(csvCell('say "hi"')).toBe('"say ""hi"""');
+  });
+
+  it('wraps in quotes when the value contains a newline', () => {
+    expect(csvCell('line1\nline2')).toBe('"line1\nline2"');
+  });
+
+  it('handles an empty string', () => {
+    expect(csvCell('')).toBe('');
+  });
+});
+
+describe('getKeys', () => {
+  it('returns an empty array for an empty input', () => {
+    expect(getKeys([])).toEqual([]);
+  });
+
+  it('returns keys from a single object', () => {
+    expect(getKeys([{a: 1, b: 2}])).toEqual(['a', 'b']);
+  });
+
+  it('unions keys across multiple objects', () => {
+    expect(getKeys([{a: 1}, {b: 2}, {a: 3, c: 4}])).toEqual(['a', 'b', 'c']);
+  });
+
+  it('deduplicates keys', () => {
+    expect(getKeys([{a: 1, b: 2}, {a: 3, b: 4}])).toEqual(['a', 'b']);
+  });
+
+  it('preserves insertion order (first appearance wins)', () => {
+    expect(getKeys([{b: 1, a: 2}, {a: 3, c: 4}])).toEqual(['b', 'a', 'c']);
+  });
+
+  it('caps the result at 12 keys', () => {
+    const row = Object.fromEntries(Array.from({length: 15}, (_, i) => [`k${i}`, i]));
+    const keys = getKeys([row]);
+    expect(keys).toHaveLength(12);
+    expect(keys).toEqual(Array.from({length: 12}, (_, i) => `k${i}`));
+  });
+});
+
+describe('printBatchOutput', () => {
+  let logLines: string[];
+  let errLines: string[];
+
+  beforeEach(() => {
+    logLines = [];
+    errLines = [];
+    vi.spyOn(console, 'log').mockImplementation((...args) => logLines.push(args.join(' ')));
+    vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => { errLines.push(String(chunk)); return true; });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('json: output is valid JSON equal to the full response', () => {
+    const resp: BatchResponse = {
+      summary: {total: 1, succeeded: 1, failed: 0, partial: 0, skipped: 0},
+      results: [{id: 'op0', action: 'users.delete', status: 'success'}],
+    };
+    printBatchOutput(resp, 'json');
+    expect(JSON.parse(logLines[0])).toEqual(resp);
+  });
+
+  it('table: failed operations are written to stderr as structured JSON', () => {
+    const resp: BatchResponse = {
+      summary: {total: 1, succeeded: 0, failed: 1, partial: 0, skipped: 0},
+      results: [{id: 'op0', action: 'users.delete', status: 'error', error: {error: 'Not found'}}],
+    };
+    printBatchOutput(resp, 'table');
+    expect(errLines.length).toBeGreaterThan(0);
+    const parsed = JSON.parse(errLines[0]);
+    expect(parsed[0].id).toBe('op0');
+    expect(parsed[0].error.error).toBe('Not found');
+  });
+});