json-fs-query 3.3.1 → 3.5.0

package/dist/cli/chooseDatabase.d.ts

@@ -0,0 +1,13 @@
+export type DatabaseOptions = {
+    database?: string;
+    databases?: string;
+};
+/**
+ * Point json-fs-query at the database the options name: `-d <path>` alone is one database folder (databasePath),
+ * `--databases <folder>` a folder of databases (databasesPath) with `-d <name>` picking one in it.
+ * @param options
+ * @returns {Promise<string>} A line saying which database is in use.
+ * @throws {Error} For an invalid database name, or a database that doesn't exist.
+ */
+export declare const chooseDatabase: (options: DatabaseOptions) => Promise<string>;
+//# sourceMappingURL=chooseDatabase.d.ts.map

package/dist/cli/chooseDatabase.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chooseDatabase = void 0;
+var _databaseStatements = require("../data/queries/databaseStatements");
+var _config = require("../data/utilities/config");
+/**
+ * Point json-fs-query at the database the options name: `-d <path>` alone is one database folder (databasePath),
+ * `--databases <folder>` a folder of databases (databasesPath) with `-d <name>` picking one in it.
+ * @param options
+ * @returns {Promise<string>} A line saying which database is in use.
+ * @throws {Error} For an invalid database name, or a database that doesn't exist.
+ */
+const chooseDatabase = async options => {
+  if (options.databases) {
+    (0, _config.configure)({
+      databasesPath: options.databases,
+      ...(options.database ? {
+        database: options.database
+      } : {})
+    });
+    if (!options.database) {
+      return `Databases: ${options.databases} (none in use yet: use <name>;)`;
+    }
+    // Checks that it exists (configure only checks the name)
+    await (0, _databaseStatements.useDatabase)(options.database);
+  } else if (options.database) {
+    // databasePath is joined straight onto file names, so it needs its trailing slash (`-d data` is data/)
+    (0, _config.configure)({
+      databasePath: options.database.endsWith('/') ? options.database : `${options.database}/`
+    });
+  }
+  return `Database: ${(0, _config.activeDatabasePath)()}`;
+};
+exports.chooseDatabase = chooseDatabase;

package/dist/cli/chooseDatabase.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.chooseDatabase=void 0;var _databaseStatements=require("../data/queries/databaseStatements"),_config=require("../data/utilities/config");const chooseDatabase=async a=>{if(a.databases){if((0,_config.configure)({databasesPath:a.databases,...a.database?{database:a.database}:{}}),!a.database)return`Databases: ${a.databases} (none in use yet: use <name>;)`;await(0,_databaseStatements.useDatabase)(a.database)}else a.database&&(0,_config.configure)({databasePath:a.database.endsWith("/")?a.database:`${a.database}/`});return`Database: ${(0,_config.activeDatabasePath)()}`};exports.chooseDatabase=chooseDatabase;

package/dist/cli/formatCsv.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Format one query's result as CSV: a header line of field names (in the order they first appear), then a line per
+ * row. A grouped read is its rows, plain values (show records) one `value` column, an empty result nothing at all.
+ * Anything else (`describe`, a single value) isn't a table: an object prints as JSON, a value as it is.
+ * @param result One entry of what query() resolves to
+ * @returns {string}
+ */
+export declare const formatCsv: (result: unknown) => string;
+//# sourceMappingURL=formatCsv.d.ts.map

package/dist/cli/formatCsv.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatCsv = void 0;
+require("core-js/modules/es.json.stringify.js");
+var _formatResult = require("./formatResult");
+const isPlainObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+/**
+ * One CSV field (RFC 4180): quoted when it holds a comma, a quote, a line break, or space at either end, with its
+ * quotes doubled. `null` and a missing field are empty and unquoted, the empty string is `""` (as psql's CSV output
+ * tells them apart). Objects and arrays are their JSON.
+ * @param value
+ * @param present False when the row doesn't have the field
+ */
+const csvField = (value, present = true) => {
+  if (!present || value === null || typeof value === 'undefined') {
+    return '';
+  }
+  const text = typeof value === 'object' ? JSON.stringify(value) : String(value);
+  return text === '' || /[",\r\n]|^\s|\s$/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+};
+/**
+ * The rows of a grouped read, in group order (each row still holds the fields it was grouped by).
+ * @param groups
+ */
+const groupRows = groups => groups.flatMap(group => group.groups ? groupRows(group.groups) : group.rows);
+/**
+ * Format one query's result as CSV: a header line of field names (in the order they first appear), then a line per
+ * row. A grouped read is its rows, plain values (show records) one `value` column, an empty result nothing at all.
+ * Anything else (`describe`, a single value) isn't a table: an object prints as JSON, a value as it is.
+ * @param result One entry of what query() resolves to
+ * @returns {string}
+ */
+const formatCsv = result => {
+  if (!Array.isArray(result)) {
+    return isPlainObject(result) ? JSON.stringify(result, null, 2) : csvField(result);
+  }
+  const rows = result.length && result.every(_formatResult.isGroup) ? groupRows(result) : result;
+  if (!rows.length) {
+    return '';
+  }
+  // A boolean, not a type guard: a guard would narrow rows to never in the branch below
+  const objects = rows.every(isPlainObject);
+  if (!objects) {
+    return ['value', ...rows.map(row => csvField(row))].join('\n');
+  }
+  const columns = [...new Set(rows.flatMap(row => Object.keys(row)))];
+  const has = (row, column) => Object.prototype.hasOwnProperty.call(row, column);
+  return [columns.map(column => csvField(column)).join(','), ...rows.map(row => columns.map(column => csvField(row[column], has(row, column))).join(','))].join('\n');
+};
+exports.formatCsv = formatCsv;

package/dist/cli/formatCsv.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.formatCsv=void 0,require("core-js/modules/es.json.stringify.js");var _formatResult=require("./formatResult");const isPlainObject=r=>null!==r&&"object"==typeof r&&!Array.isArray(r),csvField=(r,e=!0)=>{if(!e||null==r)return"";const t="object"==typeof r?JSON.stringify(r):String(r);return""===t||/[",\r\n]|^\s|\s$/.test(t)?`"${t.replace(/"/g,'""')}"`:t},groupRows=r=>r.flatMap((r=>r.groups?groupRows(r.groups):r.rows)),formatCsv=r=>{if(!Array.isArray(r))return isPlainObject(r)?JSON.stringify(r,null,2):csvField(r);const e=r.length&&r.every(_formatResult.isGroup)?groupRows(r):r;if(!e.length)return"";if(!e.every(isPlainObject))return["value",...e.map((r=>csvField(r)))].join("\n");const t=[...new Set(e.flatMap((r=>Object.keys(r))))];return[t.map((r=>csvField(r))).join(","),...e.map((r=>t.map((e=>csvField(r[e],((r,e)=>Object.prototype.hasOwnProperty.call(r,e))(r,e)))).join(",")))].join("\n")};exports.formatCsv=formatCsv;

package/dist/cli/formatResult.d.ts

@@ -0,0 +1,30 @@
+import type { Group } from '../data/queries/groupBy';
+/**
+ * How a cell shows a value that isn't plain text. Each marker reads without colour (piped output, NO_COLOR, screen
+ * readers); dimming is only extra.
+ */
+export type Markers = {
+    missing: string;
+    null: string;
+    empty: string;
+};
+export type FormatOptions = {
+    color?: boolean;
+    markers?: Partial<Markers>;
+    legend?: boolean;
+};
+export declare const defaultMarkers: Markers;
+/**
+ * Whether a value is one group of a grouped read: a field name, then either its rows or its groups, and nothing else.
+ * @param value
+ */
+export declare const isGroup: (value: unknown) => value is Group;
+/**
+ * Format one query's result for the terminal. Rows become a table, a grouped read a table per group, an empty list
+ * `(0 rows)`; anything else (`describe`, a database name) prints as it is, or as JSON for an object.
+ * @param result One entry of what query() resolves to
+ * @param options
+ * @returns {string}
+ */
+export declare const formatResult: (result: unknown, options?: FormatOptions) => string;
+//# sourceMappingURL=formatResult.d.ts.map

package/dist/cli/formatResult.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isGroup = exports.formatResult = exports.defaultMarkers = void 0;
+require("core-js/modules/es.json.stringify.js");
+var _util = require("util");
+const defaultMarkers = exports.defaultMarkers = {
+  missing: '—',
+  null: 'NULL',
+  empty: '\'\''
+};
+const dim = (text, color) => color ? `\u001b[2m${text}\u001b[22m` : text;
+// Width as it shows in the terminal: colour codes take no space
+const visibleWidth = text => (0, _util.stripVTControlCharacters)(text).length;
+const isPlainObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const groupKeys = new Set(['field', 'value', 'missing', 'rows', 'groups']);
+/**
+ * Whether a value is one group of a grouped read: a field name, then either its rows or its groups, and nothing else.
+ * @param value
+ */
+const isGroup = value => isPlainObject(value) && typeof value['field'] === 'string' && Array.isArray(value['rows']) !== Array.isArray(value['groups']) && Object.keys(value).every(key => groupKeys.has(key));
+/**
+ * The cell for one value. Text is shown as it is (line breaks as \n so a row stays on one line), numbers and booleans
+ * as written, objects and arrays as compact JSON.
+ * @param value
+ * @param present False when the row doesn't have the field at all
+ */
+exports.isGroup = isGroup;
+const toCell = (value, present = true) => {
+  if (!present) {
+    return {
+      text: '',
+      marker: 'missing'
+    };
+  }
+  if (value === null) {
+    return {
+      text: '',
+      marker: 'null'
+    };
+  }
+  if (value === '') {
+    return {
+      text: '',
+      marker: 'empty'
+    };
+  }
+  if (typeof value === 'string') {
+    return {
+      text: value.replace(/\r?\n/g, '\\n')
+    };
+  }
+  if (typeof value === 'object') {
+    return {
+      text: JSON.stringify(value)
+    };
+  }
+  return {
+    text: String(value)
+  };
+};
+const showCell = (cell, settings) => cell.marker ? dim(settings.markers[cell.marker], settings.color) : cell.text;
+const rowCount = count => `(${count} ${count === 1 ? 'row' : 'rows'})`;
+/**
+ * Draw rows as a table: columns in the order the fields first appear, a count underneath, and a legend when a marker
+ * that needs one is shown.
+ * @param rows Plain objects, or plain values (shown as one `value` column)
+ * @param settings
+ */
+const formatTable = (rows, settings) => {
+  if (!rows.length) {
+    return rowCount(0);
+  }
+  const objects = rows.every(isPlainObject);
+  const columns = objects ? [...new Set(rows.flatMap(row => Object.keys(row)))] : ['value'];
+  const has = (row, column) => Object.prototype.hasOwnProperty.call(row, column);
+  const cells = rows.map(row => objects ? columns.map(column => toCell(row[column], has(row, column))) : [toCell(row)]);
+  const body = cells.map(rowCells => rowCells.map(cell => showCell(cell, settings)));
+  const widths = columns.map((column, i) => Math.max(visibleWidth(column), ...body.map(texts => visibleWidth(texts[i]))));
+  const pad = (text, i) => text + ' '.repeat(widths[i] - visibleWidth(text));
+  const line = '+' + widths.map(width => '-'.repeat(width + 2)).join('+') + '+';
+  const tableRow = texts => '| ' + texts.map(pad).join(' | ') + ' |';
+  const lines = [line, tableRow(columns), line, ...body.map(tableRow), line, rowCount(rows.length)];
+  if (settings.legend) {
+    // Only the markers this table shows (an empty string explains itself)
+    const shown = new Set(cells.flat().map(cell => cell.marker));
+    const legend = ['missing', 'null'].filter(marker => shown.has(marker)).map(marker => `${dim(settings.markers[marker], settings.color)} ${marker}`);
+    if (legend.length) {
+      lines.push(legend.join(' · '));
+    }
+  }
+  return lines.join('\n');
+};
+const indent = (text, depth) => text.split('\n').map(line => '  '.repeat(depth) + line).join('\n');
+/**
+ * Draw the groups of a grouped read: a heading per group (`date = 2024-06-05 (3 rows)`), then its table, or its own
+ * groups indented under it.
+ * @param groups
+ * @param settings
+ * @param depth How far nested groups are indented
+ */
+const formatGroups = (groups, settings, depth = 0) => groups.map(group => {
+  const heading = group.missing ? `${group.field} is missing` : `${group.field} = ${showCell(toCell(group.value), settings)}`;
+  const content = group.groups ? `${heading} (${group.groups.length} ${group.groups.length === 1 ? 'group' : 'groups'})\n${formatGroups(group.groups, settings, depth + 1)}` : `${heading} ${rowCount(group.rows.length)}\n${indent(formatTable(group.rows, settings), 1)}`;
+  return indent(content, depth);
+}).join('\n\n');
+/**
+ * Format one query's result for the terminal. Rows become a table, a grouped read a table per group, an empty list
+ * `(0 rows)`; anything else (`describe`, a database name) prints as it is, or as JSON for an object.
+ * @param result One entry of what query() resolves to
+ * @param options
+ * @returns {string}
+ */
+const formatResult = (result, options = {}) => {
+  const settings = {
+    color: options.color ?? false,
+    markers: {
+      ...defaultMarkers,
+      ...options.markers
+    },
+    legend: options.legend ?? true
+  };
+  if (Array.isArray(result)) {
+    if (result.length && result.every(isGroup)) {
+      return formatGroups(result, settings);
+    }
+    if (result.every(isPlainObject) || result.every(value => !isPlainObject(value) && !Array.isArray(value))) {
+      return formatTable(result, settings);
+    }
+    return JSON.stringify(result, null, 2);
+  }
+  if (isPlainObject(result)) {
+    return JSON.stringify(result, null, 2);
+  }
+  return showCell(toCell(result), settings);
+};
+exports.formatResult = formatResult;

package/dist/cli/formatResult.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.isGroup=exports.formatResult=exports.defaultMarkers=void 0,require("core-js/modules/es.json.stringify.js");var _util=require("util");const defaultMarkers=exports.defaultMarkers={missing:"—",null:"NULL",empty:"''"},dim=(e,r)=>r?`${e}`:e,visibleWidth=e=>(0,_util.stripVTControlCharacters)(e).length,isPlainObject=e=>null!==e&&"object"==typeof e&&!Array.isArray(e),groupKeys=new Set(["field","value","missing","rows","groups"]),isGroup=e=>isPlainObject(e)&&"string"==typeof e.field&&Array.isArray(e.rows)!==Array.isArray(e.groups)&&Object.keys(e).every((e=>groupKeys.has(e)));exports.isGroup=isGroup;const toCell=(e,r=!0)=>r?null===e?{text:"",marker:"null"}:""===e?{text:"",marker:"empty"}:"string"==typeof e?{text:e.replace(/\r?\n/g,"\\n")}:"object"==typeof e?{text:JSON.stringify(e)}:{text:String(e)}:{text:"",marker:"missing"},showCell=(e,r)=>e.marker?dim(r.markers[e.marker],r.color):e.text,rowCount=e=>`(${e} ${1===e?"row":"rows"})`,formatTable=(e,r)=>{if(!e.length)return rowCount(0);const t=e.every(isPlainObject),s=t?[...new Set(e.flatMap((e=>Object.keys(e))))]:["value"],o=e.map((e=>t?s.map((r=>toCell(e[r],((e,r)=>Object.prototype.hasOwnProperty.call(e,r))(e,r)))):[toCell(e)])),l=o.map((e=>e.map((e=>showCell(e,r))))),i=s.map(((e,r)=>Math.max(visibleWidth(e),...l.map((e=>visibleWidth(e[r])))))),a=(e,r)=>e+" ".repeat(i[r]-visibleWidth(e)),n="+"+i.map((e=>"-".repeat(e+2))).join("+")+"+",p=e=>"| "+e.map(a).join(" | ")+" |",u=[n,p(s),n,...l.map(p),n,rowCount(e.length)];if(r.legend){const e=new Set(o.flat().map((e=>e.marker))),t=["missing","null"].filter((r=>e.has(r))).map((e=>`${dim(r.markers[e],r.color)} ${e}`));t.length&&u.push(t.join(" · "))}return u.join("\n")},indent=(e,r)=>e.split("\n").map((e=>"  ".repeat(r)+e)).join("\n"),formatGroups=(e,r,t=0)=>e.map((e=>{const s=e.missing?`${e.field} is missing`:`${e.field} = ${showCell(toCell(e.value),r)}`,o=e.groups?`${s} (${e.groups.length} ${1===e.groups.length?"group":"groups"})\n${formatGroups(e.groups,r,t+1)}`:`${s} ${rowCount(e.rows.length)}\n${indent(formatTable(e.rows,r),1)}`;return indent(o,t)})).join("\n\n"),formatResult=(e,r={})=>{const t={color:r.color??!1,markers:{...defaultMarkers,...r.markers},legend:r.legend??!0};return Array.isArray(e)?e.length&&e.every(isGroup)?formatGroups(e,t):e.every(isPlainObject)||e.every((e=>!isPlainObject(e)&&!Array.isArray(e)))?formatTable(e,t):JSON.stringify(e,null,2):isPlainObject(e)?JSON.stringify(e,null,2):showCell(toCell(e),t)};exports.formatResult=formatResult;

package/dist/cli/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Resolves once the session is idle: every line handled (the prompt), or the query finished (-q).
+ * @returns {Promise<void>}
+ */
+export declare const whenIdle: () => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.whenIdle = void 0;
+var _commander = require("commander");
+var _interactive = require("./interactive");
+var _output = require("./output");
+var _runDirect = require("./runDirect");
+// The package's own version (package.json sits two folders up from both src/cli and dist/cli)
+const {
+  version
+} = require('../../package.json');
+// Command-line options (commander exits with a message for an unknown option, and prints --help and --version)
+const program = new _commander.Command().name('jfsq').description('Query a json-fs-query database from the command line: with -q, run the query and exit; without it, open the prompt.').version(version, '-v, --version', 'print the version').option('-q, --query <query>', 'run this query (or several, separated by ;), print the results and exit').option('-d, --database <path>', 'the database folder (default database/); with --databases, the name of a database in that folder').option('--databases <folder>', 'a folder holding several databases (create database, use, show databases)').addOption(new _commander.Option('-o, --output <format>', 'how results print (at the prompt: /output <format>)').choices(_output.outputFormats).default('table')).option('--null <text>', 'how a table shows null (default NULL; at the prompt: /null <text>)').option('--missing <text>', 'how a table shows a missing field (default —; at the prompt: /missing <text>)').helpOption('-h, --help', 'print this help').addHelpText('after', `
+Examples:
+  jfsq                                         open the prompt on database/
+  jfsq -d tasks-db -q "read tasks where done = false"
+  jfsq --databases dbs -d real -q "show records"
+  jfsq -o json -q "read tasks" | jq .
+  jfsq -o csv -q "read tasks" > tasks.csv`).parse(process.argv);
+const options = program.opts();
+// Shared with the prompt, whose /output, /null and /missing commands change it
+const settings = {
+  format: options.output,
+  markers: {
+    ...(typeof options.null === 'string' ? {
+      null: options.null
+    } : {}),
+    ...(typeof options.missing === 'string' ? {
+      missing: options.missing
+    } : {})
+  }
+};
+// With -q the query runs straight away and the exit code says whether it worked; otherwise the prompt opens
+const session = typeof options.query === 'string' ? (() => {
+  const done = (0, _runDirect.runDirect)(options.query, options, settings).then(code => {
+    // exitCode rather than exit(): process.exit can cut off output still being written to a pipe
+    process.exitCode = code;
+  });
+  return {
+    whenIdle: () => done
+  };
+})() : (0, _interactive.startInteractive)(options, settings);
+/**
+ * Resolves once the session is idle: every line handled (the prompt), or the query finished (-q).
+ * @returns {Promise<void>}
+ */
+const whenIdle = () => session.whenIdle();
+exports.whenIdle = whenIdle;

package/dist/cli/index.min.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.whenIdle=void 0;var _commander=require("commander"),_interactive=require("./interactive"),_output=require("./output"),_runDirect=require("./runDirect");const{version:version}=require("../../package.json"),program=(new _commander.Command).name("jfsq").description("Query a json-fs-query database from the command line: with -q, run the query and exit; without it, open the prompt.").version(version,"-v, --version","print the version").option("-q, --query <query>","run this query (or several, separated by ;), print the results and exit").option("-d, --database <path>","the database folder (default database/); with --databases, the name of a database in that folder").option("--databases <folder>","a folder holding several databases (create database, use, show databases)").addOption(new _commander.Option("-o, --output <format>","how results print (at the prompt: /output <format>)").choices(_output.outputFormats).default("table")).option("--null <text>","how a table shows null (default NULL; at the prompt: /null <text>)").option("--missing <text>","how a table shows a missing field (default —; at the prompt: /missing <text>)").helpOption("-h, --help","print this help").addHelpText("after",'\nExamples:\n  jfsq                                         open the prompt on database/\n  jfsq -d tasks-db -q "read tasks where done = false"\n  jfsq --databases dbs -d real -q "show records"\n  jfsq -o json -q "read tasks" | jq .\n  jfsq -o csv -q "read tasks" > tasks.csv').parse(process.argv),options=program.opts(),settings={format:options.output,markers:{..."string"==typeof options.null?{null:options.null}:{},..."string"==typeof options.missing?{missing:options.missing}:{}}},session="string"==typeof options.query?(()=>{const e=(0,_runDirect.runDirect)(options.query,options,settings).then((e=>{process.exitCode=e}));return{whenIdle:()=>e}})():(0,_interactive.startInteractive)(options,settings),whenIdle=()=>session.whenIdle();exports.whenIdle=whenIdle;

package/dist/cli/interactive.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseOptions } from './chooseDatabase';
+import { OutputSettings } from './output';
+export type Session = {
+    whenIdle: () => Promise<void>;
+};
+/**
+ * Open the prompt: read queries line by line, run each one once it is complete, until /exit, Ctrl+C or the end of
+ * piped input. Piped input (`jfsq < seed.txt`, stdin not a terminal) runs the same way, but quietly: no banner, no
+ * prompts and no goodbye, only the results and errors, and the exit code is 1 when any query failed.
+ * @param options The database options
+ * @param settings The output format and markers (the /output, /null and /missing commands change them)
+ * @returns {Session}
+ */
+export declare const startInteractive: (options: DatabaseOptions, settings: OutputSettings) => Session;
+//# sourceMappingURL=interactive.d.ts.map

package/dist/cli/interactive.js

@@ -0,0 +1,257 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startInteractive = void 0;
+require("core-js/modules/es.array.includes.js");
+var readline = _interopRequireWildcard(require("readline"));
+var _util = require("util");
+var _queryStatus = require("../data/queries/queryStatus");
+var _query = require("../data/queries/query");
+var _config = require("../data/utilities/config");
+var _chooseDatabase = require("./chooseDatabase");
+var _formatResult = require("./formatResult");
+var _output = require("./output");
+var e;
+function _interopRequireWildcard(t, r) { if (!r && t && t.__esModule) return t; var n, a, o = Object.defineProperty, f = { __proto__: null, default: t }; if (Object(t) !== t) return f; if (e || "function" != typeof WeakMap || (e = new WeakMap()), e) { if (e.has(t)) return e.get(t); e.set(t, f); } for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]); return f; }
+const defaultPrompt = 'JSON-Query> ';
+// A CLI command: a slash and a word, then its value (a query never starts like this; a `/*` comment has no word)
+const commandMatch = /^\/([a-z]+)(?:\s+(.*))?$/i;
+/**
+ * Whether text holds anything to run: something other than whitespace and comments.
+ * @param text
+ * @returns {boolean}
+ */
+const hasQuery = text => text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/--[^\n]*/g, '').trim() !== '';
+/**
+ * The main prompt: the name of the database in use when there is one (it changes with `use`), otherwise JSON-Query.
+ * @returns {string}
+ */
+const mainPrompt = () => {
+  const database = (0, _config.getSetting)('database', undefined);
+  return database ? `${database}> ` : defaultPrompt;
+};
+// Continuation prompt, padded to line up with the first line and dimmed so it reads as secondary
+const continuePrefix = waitingFor => (0, _util.styleText)('dim', `${waitingFor}> `.padStart(mainPrompt().length));
+/**
+ * Open the prompt: read queries line by line, run each one once it is complete, until /exit, Ctrl+C or the end of
+ * piped input. Piped input (`jfsq < seed.txt`, stdin not a terminal) runs the same way, but quietly: no banner, no
+ * prompts and no goodbye, only the results and errors, and the exit code is 1 when any query failed.
+ * @param options The database options
+ * @param settings The output format and markers (the /output, /null and /missing commands change them)
+ * @returns {Session}
+ */
+const startInteractive = (options, settings) => {
+  // Reading a file or a pipe rather than a person typing
+  const piped = !process.stdin.isTTY;
+  // Create the interface for reading from standard input/output
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: defaultPrompt
+  });
+  // 1 when the session can't start (a bad option), so a script can tell
+  let exitCode = 0;
+  // Set when a query fails: piped input then exits 1, so a seed script can tell (the prompt carries on regardless)
+  let failed = false;
+  // Buffer to store multi-line inputs
+  let inputBuffer = '';
+  // Set once readline closes. Piped input closes it as soon as stdin ends, while queued lines may still be running,
+  // and readline throws if prompted after that
+  let closed = false;
+  /**
+   * Show the prompt, unless the session has already closed.
+   */
+  const showPrompt = () => {
+    if (!closed && !piped) {
+      rl.prompt();
+    }
+  };
+  // Lines are handled one at a time, in order: readline does not wait for an async 'line' handler, so without this
+  // queue a line typed (or piped) while a query runs would be appended to the buffer before that query finished.
+  let lineQueue = Promise.resolve();
+  const whenIdle = async () => {
+    // A handled line can queue more work (e.g. /exit queues the goodbye), so wait until the queue stops growing
+    let current;
+    do {
+      current = lineQueue;
+      await current;
+    } while (current !== lineQueue);
+  };
+  if (!piped) {
+    console.log('JSON Filesystem Query CLI');
+    console.log('Type your command. End it with a semicolon (;) and press Enter to execute.');
+    console.log('Type "/exit" or press Ctrl+C to quit.');
+  }
+  /**
+   * Print a confirmation for a person typing; piped input stays quiet, so its output is only results (e.g. for jq).
+   * @param {string} message
+   */
+  const say = message => {
+    if (!piped) {
+      console.log(message);
+    }
+  };
+  /**
+   * Run one CLI command. Without a value each one says what it is set to now.
+   * @param {string} line The trimmed line, e.g. `/output csv` or `/null (null)`
+   */
+  const runCommand = line => {
+    const [, name, value = ''] = line.match(commandMatch);
+    switch (name.toLowerCase()) {
+      case 'output':
+        {
+          const outputFormat = value.toLowerCase();
+          if (value && !_output.outputFormats.includes(outputFormat)) {
+            failed = true;
+            (0, _output.printError)(`Unknown output "${value}": use ${_output.outputFormats.join(', ')}`);
+            return;
+          }
+          if (value) {
+            settings.format = outputFormat;
+          }
+          say(`Output: ${settings.format}`);
+          return;
+        }
+      case 'null':
+      case 'missing':
+        {
+          const marker = name.toLowerCase();
+          if (value) {
+            settings.markers = {
+              ...settings.markers,
+              [marker]: value
+            };
+          }
+          say(`${marker === 'null' ? 'Null' : 'Missing'} shows as: ${settings.markers[marker] ?? _formatResult.defaultMarkers[marker]}`);
+          return;
+        }
+      default:
+        failed = true;
+        (0, _output.printError)(`Unknown command /${name}: use /output <${_output.outputFormats.join('|')}>, /null <text>, /missing <text> or /exit`);
+    }
+  };
+  /**
+   * Run a completed buffer through the query parser. A parse or runtime error is printed and the session carries on.
+   * @param {string} input The completed query buffer (one or more queries)
+   * @returns {Promise<void>}
+   */
+  const processInput = async input => {
+    try {
+      (0, _output.assertPrintable)(settings);
+      (0, _output.printResults)(await (0, _query.query)(input), settings);
+    } catch (error) {
+      failed = true;
+      (0, _output.printError)(error);
+    }
+  };
+  /**
+   * Handle one line of input: exit, skip, add to the buffer, or run the buffer once the query is complete.
+   * @param {string} line The line as typed, without its line ending
+   * @returns {Promise<void>}
+   */
+  const handleLine = async line => {
+    // The session didn't start (a bad option): lines piped after it must not run against the wrong database
+    if (exitCode) {
+      return;
+    }
+    const trimmedLine = line.trim();
+    // Check if the user wants to exit
+    if (!inputBuffer && trimmedLine.toLowerCase() === '/exit') {
+      rl.close();
+      return;
+    }
+    // A CLI command (/output, /null, /missing) at the start of a query: never sent to the query parser
+    if (!inputBuffer && commandMatch.test(trimmedLine)) {
+      runCommand(trimmedLine);
+      showPrompt();
+      return;
+    }
+    // Skip blank lines on their own, accept them mid-query
+    if (!inputBuffer && !trimmedLine) {
+      showPrompt();
+      return;
+    }
+    // Append current line to the buffer
+    inputBuffer += (inputBuffer ? '\n' : '') + line;
+    const status = (0, _queryStatus.queryStatus)(inputBuffer);
+    // Check if the line ends the query (closed query and semicolon present)
+    if (status.complete) {
+      // Take the buffer before running, so the next query starts empty even if this one fails
+      const input = inputBuffer;
+      inputBuffer = '';
+      await processInput(input);
+      // After the query, so a `use` in it shows in the prompt
+      rl.setPrompt(mainPrompt());
+    } else {
+      // Change prompt visually to show it is expecting continuation
+      rl.setPrompt(continuePrefix(status.waitingFor));
+    }
+    showPrompt();
+  };
+  // Handle line-by-line input, queued so each line waits for the one before it
+  rl.on('line', line => {
+    lineQueue = lineQueue.then(() => handleLine(line))
+    // Never let one failed line stop the queue (query errors are already handled in processInput)
+    .catch(error => {
+      (0, _output.printError)(error);
+      showPrompt();
+    });
+  });
+  rl.on('SIGINT', () => {
+    if (!inputBuffer && !rl.line) {
+      rl.close();
+      return;
+    }
+    rl.write(null, {
+      ctrl: true,
+      name: 'u'
+    });
+    inputBuffer = '';
+    rl.setPrompt(mainPrompt());
+    showPrompt();
+  });
+  // Handle graceful exit on Ctrl+C, /exit or the end of piped input, after any queued lines have run
+  rl.on('close', () => {
+    closed = true;
+    lineQueue = lineQueue.then(async () => {
+      // A file whose last query has no closing `;` still runs it (unless all that's left is comments or space)
+      if (piped && !exitCode && hasQuery(inputBuffer)) {
+        const input = inputBuffer;
+        inputBuffer = '';
+        await processInput(input);
+      }
+      if (!exitCode && !piped) {
+        console.log('\nGoodbye!');
+      }
+      process.exit(exitCode || (piped && failed ? 1 : 0));
+    });
+  });
+  /**
+   * Point the session at the database the options name, then open the prompt. A bad option (an invalid name, a
+   * database that doesn't exist) prints the error and ends the session with exit code 1.
+   * @returns {Promise<void>}
+   */
+  const start = async () => {
+    try {
+      const database = await (0, _chooseDatabase.chooseDatabase)(options);
+      if (!piped) {
+        console.log(`${database}\n`);
+      }
+    } catch (error) {
+      (0, _output.printError)(error);
+      exitCode = 1;
+      rl.close();
+      return;
+    }
+    rl.setPrompt(mainPrompt());
+    showPrompt();
+  };
+  // Lines typed before the session is ready wait for it
+  lineQueue = start();
+  return {
+    whenIdle
+  };
+};
+exports.startInteractive = startInteractive;

package/dist/cli/interactive.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.startInteractive=void 0,require("core-js/modules/es.array.includes.js");var e,readline=_interopRequireWildcard(require("readline")),_util=require("util"),_queryStatus=require("../data/queries/queryStatus"),_query=require("../data/queries/query"),_config=require("../data/utilities/config"),_chooseDatabase=require("./chooseDatabase"),_formatResult=require("./formatResult"),_output=require("./output");function _interopRequireWildcard(t,r){if(!r&&t&&t.__esModule)return t;var o,s,a=Object.defineProperty,n={__proto__:null,default:t};if(Object(t)!==t)return n;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(t))return e.get(t);e.set(t,n)}for(s in t)"default"!==s&&{}.hasOwnProperty.call(t,s)&&((o=a&&Object.getOwnPropertyDescriptor(t,s))&&(o.get||o.set)?a(n,s,o):n[s]=t[s]);return n}const defaultPrompt="JSON-Query> ",commandMatch=/^\/([a-z]+)(?:\s+(.*))?$/i,hasQuery=t=>""!==t.replace(/\/\*[\s\S]*?\*\//g,"").replace(/--[^\n]*/g,"").trim(),mainPrompt=()=>{const t=(0,_config.getSetting)("database",void 0);return t?`${t}> `:defaultPrompt},continuePrefix=t=>(0,_util.styleText)("dim",`${t}> `.padStart(mainPrompt().length)),startInteractive=(t,e)=>{const r=!process.stdin.isTTY,o=readline.createInterface({input:process.stdin,output:process.stdout,prompt:defaultPrompt});let s=0,a=!1,n="",u=!1;const i=()=>{u||r||o.prompt()};let c=Promise.resolve();r||(console.log("JSON Filesystem Query CLI"),console.log("Type your command. End it with a semicolon (;) and press Enter to execute."),console.log('Type "/exit" or press Ctrl+C to quit.'));const l=t=>{r||console.log(t)},p=async t=>{try{(0,_output.assertPrintable)(e),(0,_output.printResults)(await(0,_query.query)(t),e)}catch(t){a=!0,(0,_output.printError)(t)}},m=async t=>{if(s)return;const r=t.trim();if(!n&&"/exit"===r.toLowerCase())return void o.close();if(!n&&commandMatch.test(r))return(t=>{const[,r,o=""]=t.match(commandMatch);switch(r.toLowerCase()){case"output":{const t=o.toLowerCase();return o&&!_output.outputFormats.includes(t)?(a=!0,void(0,_output.printError)(`Unknown output "${o}": use ${_output.outputFormats.join(", ")}`)):(o&&(e.format=t),void l(`Output: ${e.format}`))}case"null":case"missing":{const t=r.toLowerCase();return o&&(e.markers={...e.markers,[t]:o}),void l(`${"null"===t?"Null":"Missing"} shows as: ${e.markers[t]??_formatResult.defaultMarkers[t]}`)}default:a=!0,(0,_output.printError)(`Unknown command /${r}: use /output <${_output.outputFormats.join("|")}>, /null <text>, /missing <text> or /exit`)}})(r),void i();if(!n&&!r)return void i();n+=(n?"\n":"")+t;const u=(0,_queryStatus.queryStatus)(n);if(u.complete){const t=n;n="",await p(t),o.setPrompt(mainPrompt())}else o.setPrompt(continuePrefix(u.waitingFor));i()};o.on("line",(t=>{c=c.then((()=>m(t))).catch((t=>{(0,_output.printError)(t),i()}))})),o.on("SIGINT",(()=>{n||o.line?(o.write(null,{ctrl:!0,name:"u"}),n="",o.setPrompt(mainPrompt()),i()):o.close()})),o.on("close",(()=>{u=!0,c=c.then((async()=>{if(r&&!s&&hasQuery(n)){const t=n;n="",await p(t)}s||r||console.log("\nGoodbye!"),process.exit(s||(r&&a?1:0))}))}));return c=(async()=>{try{const e=await(0,_chooseDatabase.chooseDatabase)(t);r||console.log(`${e}\n`)}catch(t){return(0,_output.printError)(t),s=1,void o.close()}o.setPrompt(mainPrompt()),i()})(),{whenIdle:async()=>{let t;do{t=c,await t}while(t!==c)}}};exports.startInteractive=startInteractive;