@onyx.dev/onyx-database 2.3.0 → 2.4.1

package/dist/gen/cli/generate.cjs

@@ -1287,6 +1287,374 @@ function computeSchemaDiff(apiSchema, localSchema) {
   return { newTables, removedTables, changedTables };
 }
 
+// src/helpers/query-formatters.ts
+var DEFAULT_TABLE_OPTIONS = {
+  headers: true,
+  maxColumnWidth: 80,
+  flattenNestedObjects: false,
+  nestedSeparator: ".",
+  nullValue: ""
+};
+var DEFAULT_TREE_OPTIONS = {
+  rootLabel: "results",
+  keyField: "",
+  includeRoot: true,
+  maxDepth: Number.POSITIVE_INFINITY,
+  nullValue: ""
+};
+var DEFAULT_CSV_OPTIONS = {
+  headers: true,
+  delimiter: ",",
+  quote: '"',
+  escape: '"',
+  newline: "\n",
+  flattenNestedObjects: true,
+  nestedSeparator: ".",
+  nullValue: ""
+};
+var DEFAULT_JSON_OPTIONS = {
+  pretty: true,
+  indent: 2
+};
+function isDate(value) {
+  return value instanceof Date;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !isDate(value);
+}
+function normalizeRecord(value) {
+  if (isRecord(value)) {
+    return value;
+  }
+  return { value };
+}
+function normalizeScalar(value, nullValue) {
+  if (value == null) return nullValue;
+  if (isDate(value)) return value.toISOString();
+  if (typeof value === "string") return value;
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+function inlineValue(value, nullValue) {
+  if (value == null) return nullValue;
+  if (isDate(value)) return value.toISOString();
+  if (Array.isArray(value)) {
+    return value.length === 0 ? "[]" : `[${value.map((entry) => inlineValue(entry, nullValue)).join(", ")}]`;
+  }
+  if (isRecord(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    return entries.map(([key, entry]) => `${key}=${inlineValue(entry, nullValue)}`).join(", ");
+  }
+  if (typeof value === "bigint") return value.toString();
+  return String(value);
+}
+function escapeTableCell(value) {
+  return value.replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+function truncate(value, maxWidth) {
+  if (maxWidth < 1) return "";
+  if (value.length <= maxWidth) return value;
+  if (maxWidth <= 3) return ".".repeat(maxWidth);
+  return `${value.slice(0, Math.max(0, maxWidth - 3))}...`;
+}
+function padRight(value, width) {
+  if (value.length >= width) return value;
+  return value + " ".repeat(width - value.length);
+}
+function flattenValue(value, separator, prefix, out) {
+  if (isRecord(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      out[prefix] = {};
+      return;
+    }
+    for (const [key, entry] of entries) {
+      const path = prefix ? `${prefix}${separator}${key}` : key;
+      flattenValue(entry, separator, path, out);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      out[prefix] = [];
+      return;
+    }
+    value.forEach((entry, index) => {
+      const path = prefix ? `${prefix}${separator}${index}` : String(index);
+      flattenValue(entry, separator, path, out);
+    });
+    return;
+  }
+  out[prefix] = value;
+}
+function toFlatRow(record, separator) {
+  const out = {};
+  for (const [key, value] of Object.entries(record)) {
+    flattenValue(value, separator, key, out);
+  }
+  return out;
+}
+function discoveredColumns(rows) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  return columns;
+}
+function orderColumns(discovered, preferred, flattenNestedObjects, separator) {
+  if (!preferred || preferred.length === 0) return discovered;
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addColumn = (column) => {
+    if (!seen.has(column)) {
+      seen.add(column);
+      ordered.push(column);
+    }
+  };
+  for (const field of preferred) {
+    if (flattenNestedObjects) {
+      let matched = false;
+      for (const column of discovered) {
+        if (column === field || column.startsWith(`${field}${separator}`)) {
+          addColumn(column);
+          matched = true;
+        }
+      }
+      if (!matched) {
+        addColumn(field);
+      }
+      continue;
+    }
+    addColumn(field);
+  }
+  for (const column of discovered) {
+    addColumn(column);
+  }
+  return ordered;
+}
+function normalizeTableRows(records, preferredColumns, options) {
+  const normalized = records.map(normalizeRecord);
+  if (options.flattenNestedObjects) {
+    const flatRows = normalized.map((record) => toFlatRow(record, options.nestedSeparator));
+    const columns2 = orderColumns(
+      discoveredColumns(flatRows),
+      preferredColumns,
+      true,
+      options.nestedSeparator
+    );
+    const rows2 = flatRows.map((row) => columns2.map((column) => escapeTableCell(truncate(
+      inlineValue(row[column], options.nullValue),
+      options.maxColumnWidth
+    ))));
+    return { columns: columns2, rows: rows2 };
+  }
+  const topLevelRows = normalized.map((record) => ({ ...record }));
+  const columns = orderColumns(
+    discoveredColumns(topLevelRows),
+    preferredColumns,
+    false,
+    options.nestedSeparator
+  );
+  const rows = topLevelRows.map((row) => columns.map((column) => escapeTableCell(truncate(
+    inlineValue(row[column], options.nullValue),
+    options.maxColumnWidth
+  ))));
+  return { columns, rows };
+}
+function formatQueryResultsAsTable(records, options, preferredColumns) {
+  const final = { ...DEFAULT_TABLE_OPTIONS, ...options };
+  const { columns, rows } = normalizeTableRows(records, preferredColumns, final);
+  if (columns.length === 0) return "";
+  const headerCells = columns.map((column) => truncate(column, final.maxColumnWidth));
+  const widths = columns.map((_, index) => {
+    const headerWidth = final.headers ? headerCells[index].length : 0;
+    const rowWidth = rows.reduce((max, row) => Math.max(max, row[index].length), 0);
+    return Math.max(headerWidth, rowWidth);
+  });
+  const border = (left, join, right) => `${left}${widths.map((width) => "\u2500".repeat(width + 2)).join(join)}${right}`;
+  const renderRow = (cells) => `\u2502 ${cells.map((cell, index) => padRight(cell, widths[index])).join(" \u2502 ")} \u2502`;
+  const lines = [border("\u250C", "\u252C", "\u2510")];
+  if (final.headers) {
+    lines.push(renderRow(headerCells));
+    lines.push(border("\u251C", "\u253C", "\u2524"));
+  }
+  for (const row of rows) {
+    lines.push(renderRow(row));
+  }
+  lines.push(border("\u2514", "\u2534", "\u2518"));
+  return lines.join("\n");
+}
+function encodeCsvCell(value, options) {
+  const escapedQuote = `${options.escape}${options.quote}`;
+  const escaped = value.split(options.quote).join(escapedQuote);
+  const needsQuoting = escaped.includes(options.delimiter) || escaped.includes(options.quote) || escaped.includes("\n") || escaped.includes("\r");
+  if (!needsQuoting) return escaped;
+  return `${options.quote}${escaped}${options.quote}`;
+}
+function normalizeCsvRows(records, preferredColumns, options) {
+  const normalized = records.map(normalizeRecord);
+  if (options.flattenNestedObjects) {
+    const flatRows = normalized.map((record) => toFlatRow(record, options.nestedSeparator));
+    const columns2 = orderColumns(
+      discoveredColumns(flatRows),
+      preferredColumns,
+      true,
+      options.nestedSeparator
+    );
+    const rows2 = flatRows.map((row) => columns2.map((column) => normalizeScalar(row[column], options.nullValue)));
+    return { columns: columns2, rows: rows2 };
+  }
+  const topLevelRows = normalized.map((record) => ({ ...record }));
+  const columns = orderColumns(
+    discoveredColumns(topLevelRows),
+    preferredColumns,
+    false,
+    options.nestedSeparator
+  );
+  const rows = topLevelRows.map((row) => columns.map((column) => inlineValue(row[column], options.nullValue)));
+  return { columns, rows };
+}
+function formatQueryResultsAsCsv(records, options, preferredColumns) {
+  const final = { ...DEFAULT_CSV_OPTIONS, ...options };
+  const { columns, rows } = normalizeCsvRows(records, preferredColumns, final);
+  const lines = [];
+  if (final.headers && columns.length > 0) {
+    lines.push(columns.map((column) => encodeCsvCell(column, final)).join(final.delimiter));
+  }
+  for (const row of rows) {
+    lines.push(row.map((cell) => encodeCsvCell(cell, final)).join(final.delimiter));
+  }
+  return lines.join(final.newline);
+}
+function normalizeJsonValue(value) {
+  if (value === void 0) return null;
+  if (value === null) return null;
+  if (isDate(value)) return value.toISOString();
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map((entry) => normalizeJsonValue(entry));
+  if (isRecord(value)) {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      out[key] = normalizeJsonValue(entry);
+    }
+    return out;
+  }
+  return value;
+}
+function formatQueryResultsAsJson(records, options) {
+  const final = { ...DEFAULT_JSON_OPTIONS, ...options };
+  const normalized = records.map((record) => normalizeJsonValue(normalizeRecord(record)));
+  return final.pretty ? JSON.stringify(normalized, null, final.indent) : JSON.stringify(normalized);
+}
+function findDefaultTreeKeyField(record) {
+  for (const candidate of ["code", "id", "name"]) {
+    if (candidate in record) return candidate;
+  }
+  const keys = Object.keys(record);
+  return keys.length > 0 ? keys[0] : void 0;
+}
+function buildTreeNodesFromValue(value, options, depth) {
+  if (depth >= options.maxDepth) {
+    return [{ label: inlineValue(value, options.nullValue) }];
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => {
+      if (!isRecord(entry) && !Array.isArray(entry)) {
+        return { label: `[${index}]: ${inlineValue(entry, options.nullValue)}` };
+      }
+      return {
+        label: `[${index}]`,
+        children: buildTreeNodesFromValue(entry, options, depth + 1)
+      };
+    });
+  }
+  return Object.entries(value).map(([key, entry]) => {
+    if (isRecord(entry) || Array.isArray(entry)) {
+      if (depth + 1 >= options.maxDepth) {
+        return { label: `${key}: ${inlineValue(entry, options.nullValue)}` };
+      }
+      return {
+        label: key,
+        children: buildTreeNodesFromValue(entry, options, depth + 1)
+      };
+    }
+    return { label: `${key}: ${inlineValue(entry, options.nullValue)}` };
+  });
+}
+function buildRecordTreeNode(record, index, options) {
+  const keyField = options.keyField || findDefaultTreeKeyField(record);
+  const entries = Object.entries(record);
+  if (!keyField || !(keyField in record)) {
+    return {
+      label: `row ${index + 1}`,
+      children: buildTreeNodesFromValue(record, options, 0)
+    };
+  }
+  const labelValue = inlineValue(record[keyField], options.nullValue);
+  const childEntries = entries.filter(([key]) => key !== keyField);
+  return {
+    label: labelValue,
+    children: childEntries.length > 0 ? childEntries.map(([key, value]) => {
+      if (isRecord(value) || Array.isArray(value)) {
+        if (1 > options.maxDepth) {
+          return { label: `${key}: ${inlineValue(value, options.nullValue)}` };
+        }
+        return {
+          label: key,
+          children: buildTreeNodesFromValue(value, options, 1)
+        };
+      }
+      return { label: `${key}: ${inlineValue(value, options.nullValue)}` };
+    }) : void 0
+  };
+}
+function renderTreeNodes(nodes, prefix = "") {
+  const lines = [];
+  nodes.forEach((node, index) => {
+    const isLast = index === nodes.length - 1;
+    const branch = isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
+    lines.push(`${prefix}${branch}${node.label}`);
+    if (node.children && node.children.length > 0) {
+      const childPrefix = `${prefix}${isLast ? "   " : "\u2502  "}`;
+      lines.push(...renderTreeNodes(node.children, childPrefix));
+    }
+  });
+  return lines;
+}
+function formatQueryResultsAsTree(records, options) {
+  const final = { ...DEFAULT_TREE_OPTIONS, ...options };
+  const nodes = records.map((record, index) => buildRecordTreeNode(normalizeRecord(record), index, final));
+  if (!final.includeRoot) {
+    return renderTreeNodes(nodes).join("\n");
+  }
+  const lines = [final.rootLabel];
+  if (nodes.length > 0) {
+    lines.push(...renderTreeNodes(nodes));
+  }
+  return lines.join("\n");
+}
+async function collectAllQueryRecords(getPage, initialNextPage) {
+  const records = [];
+  let nextPage = initialNextPage;
+  while (true) {
+    const page = await getPage(nextPage);
+    if (Array.isArray(page.records)) {
+      records.push(...page.records);
+    }
+    if (!page.nextPage) break;
+    nextPage = page.nextPage;
+  }
+  return records;
+}
+
 // src/impl/onyx-core.ts
 var DEFAULT_CACHE_TTL = 5 * 60 * 1e3;
 function toSingleCondition(criteria) {
@@ -1815,7 +2183,7 @@ var OnyxDatabaseImpl = class {
 };
 var QueryBuilderImpl = class {
   db;
-  table;
+  tableName;
   fields = null;
   resolvers = null;
   conditions = null;
@@ -1834,12 +2202,12 @@ var QueryBuilderImpl = class {
   onItemListener = null;
   constructor(db, table, partition) {
     this.db = db;
-    this.table = table;
+    this.tableName = table;
     this.partitionValue = partition;
   }
   ensureTable() {
-    if (!this.table) throw new Error("Table is not defined. Call from(<table>) first.");
-    return this.table;
+    if (!this.tableName) throw new Error("Table is not defined. Call from(<table>) first.");
+    return this.tableName;
   }
   serializableConditions() {
     return normalizeCondition(this.conditions);
@@ -1847,7 +2215,7 @@ var QueryBuilderImpl = class {
   toSelectQuery() {
     return {
       type: "SelectQuery",
-      table: this.table,
+      table: this.tableName,
       fields: this.fields,
       conditions: this.serializableConditions(),
       sort: this.sort,
@@ -1868,13 +2236,25 @@ var QueryBuilderImpl = class {
       partition: this.partitionValue ?? null
     };
   }
+  async getAllRecordsForFormatting() {
+    if (this.mode !== "select") throw new Error("Formatting is only applicable in select mode.");
+    const table = this.ensureTable();
+    const select = this.toSelectQuery();
+    const pageSize = this.pageSizeValue ?? void 0;
+    const initialNextPage = this.nextPageValue ?? void 0;
+    return collectAllQueryRecords((nextPage) => this.db._queryPage(table, select, {
+      pageSize,
+      nextPage,
+      partition: this.partitionValue
+    }), initialNextPage);
+  }
   toSerializableQueryObject() {
     const table = this.ensureTable();
     const payload = this.mode === "update" ? this.toUpdateQuery() : this.toSelectQuery();
     return { ...payload, table };
   }
   from(table) {
-    this.table = table;
+    this.tableName = table;
     return this;
   }
   select(...fields) {
@@ -2006,6 +2386,26 @@ var QueryBuilderImpl = class {
   async one() {
     return this.firstOrNull();
   }
+  async table(options) {
+    return formatQueryResultsAsTable(
+      await this.getAllRecordsForFormatting(),
+      options,
+      this.fields ?? void 0
+    );
+  }
+  async tree(options) {
+    return formatQueryResultsAsTree(await this.getAllRecordsForFormatting(), options);
+  }
+  async csv(options) {
+    return formatQueryResultsAsCsv(
+      await this.getAllRecordsForFormatting(),
+      options,
+      this.fields ?? void 0
+    );
+  }
+  async json(options) {
+    return formatQueryResultsAsJson(await this.getAllRecordsForFormatting(), options);
+  }
   async delete() {
     if (this.mode !== "select") throw new Error("delete() is only applicable in select mode.");
     const table = this.ensureTable();