@noy-db/as-xlsx 0.2.0-pre.21 → 0.2.0-pre.24

package/dist/index.cjs

@@ -35,12 +35,15 @@ __export(index_exports, {
   download: () => download,
   formula: () => formula,
   fromBytes: () => fromBytes,
+  inferSchema: () => inferSchema,
   readXlsx: () => readXlsx,
   styled: () => styled,
   toBytes: () => toBytes,
   toBytesFromCollection: () => toBytesFromCollection,
+  toBytesMultiVault: () => toBytesMultiVault,
   write: () => write,
-  writeXlsx: () => writeXlsx
+  writeXlsx: () => writeXlsx,
+  zodSourceFor: () => zodSourceFor
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -465,6 +468,92 @@ function stringAttr(raw) {
   return "";
 }
 
+// src/infer.ts
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2})?/;
+function inferType(vals) {
+  if (vals.length === 0) return "string";
+  if (vals.every((v) => typeof v === "boolean")) return "boolean";
+  if (vals.every((v) => typeof v === "number")) return "number";
+  if (vals.every((v) => typeof v === "string" && ISO_DATE.test(v))) return "date";
+  return "string";
+}
+async function inferSchema(bytes, options = {}) {
+  const skip = new Set(options.skipSheets ?? []);
+  const decoded = await readXlsx(bytes);
+  const sheets = [];
+  for (const sh of decoded.sheets) {
+    if (sh.name.startsWith("_") || skip.has(sh.name)) continue;
+    const headerRow = sh.rows[0] ?? {};
+    const colToField = /* @__PURE__ */ new Map();
+    const fields = [];
+    for (const [letter, val] of Object.entries(headerRow)) {
+      const name = typeof val === "string" ? val.trim() : typeof val === "number" || typeof val === "boolean" ? String(val) : "";
+      if (!name) continue;
+      colToField.set(letter, name);
+      fields.push(name);
+    }
+    const records = sh.rows.slice(1).map((row) => {
+      const rec = {};
+      for (const [letter, val] of Object.entries(row)) {
+        const f = colToField.get(letter);
+        if (f !== void 0) rec[f] = val;
+      }
+      return rec;
+    });
+    sheets.push({ name: sh.name, fields, records });
+  }
+  const valuesOf = (s, f) => s.records.map((r) => r[f]).filter((v) => v != null && v !== "");
+  const idFieldOf = (s) => {
+    if (s.fields.includes("id")) return "id";
+    for (const f of s.fields) {
+      const vals = valuesOf(s, f);
+      if (vals.length > 0 && new Set(vals.map((v) => String(v))).size === vals.length) return f;
+    }
+    return s.fields[0] ?? "id";
+  };
+  const meta = sheets.map((s) => ({ s, idField: idFieldOf(s) }));
+  const idValuesByName = /* @__PURE__ */ new Map();
+  for (const { s, idField } of meta) {
+    idValuesByName.set(s.name, new Set(valuesOf(s, idField).map((v) => String(v))));
+  }
+  const collections = {};
+  for (const { s, idField } of meta) {
+    const fields = {};
+    for (const f of s.fields) {
+      const vals = valuesOf(s, f);
+      const type = inferType(vals);
+      let references;
+      if (f !== idField && type === "string" && vals.length > 0) {
+        const distinct = new Set(vals.map((v) => String(v)));
+        for (const { s: other } of meta) {
+          if (other.name === s.name) continue;
+          const ids = idValuesByName.get(other.name);
+          if (ids && ids.size > 0 && [...distinct].every((v) => ids.has(v))) {
+            references = other.name;
+            break;
+          }
+        }
+      }
+      fields[f] = references ? { type, references } : { type };
+    }
+    collections[s.name] = { idField, fields };
+  }
+  return { collections };
+}
+function zodSourceFor(schema) {
+  const zType = (t) => t === "number" ? "z.number()" : t === "boolean" ? "z.boolean()" : t === "date" ? "z.string().datetime()" : "z.string()";
+  const blocks = [`import { z } from 'zod'`];
+  for (const [name, c] of Object.entries(schema.collections)) {
+    const lines = Object.entries(c.fields).map(
+      ([f, d]) => `  ${f}: ${zType(d.type)},${d.references ? ` // \u2192 ${d.references}` : ""}`
+    );
+    blocks.push(`export const ${name}Schema = z.object({
+${lines.join("\n")}
+})`);
+  }
+  return blocks.join("\n\n");
+}
+
 // src/index.ts
 var import_hub = require("@noy-db/hub");
 async function toBytesFromCollection(vault, collectionName) {
@@ -524,6 +613,95 @@ async function write(vault, path, options) {
   const { writeFile } = await import("fs/promises");
   await writeFile(path, bytes);
 }
+async function toBytesMultiVault(entries, options = {}) {
+  const sep = options.sheetSeparator ?? "_";
+  for (const entry of entries) {
+    entry.vault.assertCanExport("plaintext", "xlsx");
+  }
+  const loaded = [];
+  const denormIndex = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const prefix = entry.label ?? entry.vault.name;
+    for (const s of entry.sheets) {
+      const all = await entry.vault.collection(s.collection).list();
+      const records = [];
+      for (const item of all) {
+        const r = item;
+        const allow = entry.closure?.get(s.collection);
+        if (allow && !allow.has(String(r.id))) continue;
+        if (s.filter && !s.filter(r)) continue;
+        records.push(r);
+      }
+      loaded.push({ entry, prefix, sheetOpt: s, records });
+      const indexKey = `${prefix}/${s.collection}`;
+      const collectionIndex = denormIndex.get(indexKey) ?? /* @__PURE__ */ new Map();
+      denormIndex.set(indexKey, collectionIndex);
+      for (const r of records) {
+        const idVal = r.id;
+        if (idVal != null) collectionIndex.set(safeStringify(idVal), r);
+      }
+    }
+  }
+  for (const ls of loaded) {
+    for (const d of ls.sheetOpt.denormalize ?? []) {
+      if (d.from.keyField === "id") continue;
+      const indexKey = `${d.from.label}/${d.from.collection}`;
+      const idx = denormIndex.get(indexKey);
+      if (!idx) continue;
+      const srcLoaded = loaded.find(
+        (l) => l.prefix === d.from.label && l.sheetOpt.collection === d.from.collection
+      );
+      if (!srcLoaded) continue;
+      for (const r of srcLoaded.records) {
+        const kv = r[d.from.keyField];
+        if (kv != null) idx.set(safeStringify(kv), r);
+      }
+    }
+  }
+  const allSheets = [];
+  const manifestRows = [];
+  for (const { prefix, sheetOpt: s, records } of loaded) {
+    const baseColumns = s.columns ?? inferColumns(records);
+    const denormDefs = s.denormalize ?? [];
+    if (denormDefs.length === 0) {
+      const sheetName2 = `${prefix}${sep}${s.name}`;
+      allSheets.push(buildFlatSheet(sheetName2, baseColumns, records));
+      manifestRows.push([prefix, s.collection, records.length]);
+      continue;
+    }
+    const allColumns = [...baseColumns, ...denormDefs.map((d) => d.column)];
+    const sheetName = `${prefix}${sep}${s.name}`;
+    const rows = records.map((r) => {
+      const baseCells = baseColumns.map((c) => r[c] ?? null);
+      const denormCells = denormDefs.map((d) => {
+        const idxKey = `${d.from.label}/${d.from.collection}`;
+        const idx = denormIndex.get(idxKey);
+        if (!idx) return "";
+        const fkVal = r[d.localField];
+        if (fkVal == null) return "";
+        const supporting = idx.get(safeStringify(fkVal));
+        if (!supporting) return "";
+        return supporting[d.from.pick] ?? "";
+      });
+      return [...baseCells, ...denormCells];
+    });
+    allSheets.push({ name: sheetName, header: allColumns, rows });
+    manifestRows.push([prefix, s.collection, records.length]);
+  }
+  allSheets.unshift({
+    name: "_manifest",
+    header: ["Vault", "Collection", "Records"],
+    rows: manifestRows
+  });
+  return writeXlsx(allSheets);
+}
+function buildFlatSheet(name, columns, records) {
+  return {
+    name,
+    header: [...columns],
+    rows: records.map((r) => columns.map((c) => r[c] ?? null))
+  };
+}
 function safeStringify(v) {
   if (typeof v === "string") return v;
   if (typeof v === "number" || typeof v === "boolean" || typeof v === "bigint") return String(v);
@@ -682,6 +860,7 @@ async function buildSmartSheets(vault, options) {
       return [m.opt.name, m.records.length, Object.entries(refs).map(([f, r]) => `${f}\u2192${r.target}`).join(", ")];
     })
   };
+  const dialect = options.dialect ?? "excel";
   const summarySheets = [];
   for (const spec of options.summaries ?? []) {
     const src = sheetMeta.get(spec.from);
@@ -689,6 +868,26 @@ async function buildSmartSheets(vault, options) {
     const gCol = src?.colIndex.get(spec.groupBy);
     if (!src || !srcMat || gCol === void 0) continue;
     const gLetter = colLetter(gCol);
+    if (dialect === "sheets") {
+      const selects = [];
+      const labels = [];
+      for (const a of spec.aggregates) {
+        if (a.op === "count") {
+          selects.push(`COUNT(${gLetter})`);
+          labels.push(`COUNT(${gLetter}) '${a.label}'`);
+          continue;
+        }
+        const vIdx = a.field ? src.colIndex.get(a.field) : void 0;
+        if (vIdx === void 0) continue;
+        const vL = colLetter(vIdx);
+        const fn = a.op === "sum" ? "SUM" : "AVG";
+        selects.push(`${fn}(${vL})`);
+        labels.push(`${fn}(${vL}) '${a.label}'`);
+      }
+      const q = `QUERY('${src.name}'!A:ZZ, "SELECT ${gLetter}, ${selects.join(", ")} GROUP BY ${gLetter} LABEL ${labels.join(", ")}", 1)`;
+      summarySheets.push({ name: spec.name, rows: [[formula(q)]] });
+      continue;
+    }
     const seen = /* @__PURE__ */ new Set();
     const groups = [];
     for (const r of srcMat.records) {
@@ -818,6 +1017,13 @@ async function fromBytes(vault, bytes, options) {
     } catch {
     }
   }
+  const i18nBases = /* @__PURE__ */ new Set();
+  if (options.smart) {
+    for (const field of colToField.values()) {
+      const m = /^(.+)__(.+)$/.exec(field);
+      if (m && m[2] !== "label") i18nBases.add(m[1]);
+    }
+  }
   const records = [];
   for (let i = headerRowIdx + 1; i < allRows.length; i++) {
     const row = allRows[i];
@@ -826,6 +1032,22 @@ async function fromBytes(vault, bytes, options) {
     for (const [col, value] of Object.entries(row)) {
       const field = colToField.get(col);
       if (field === void 0) continue;
+      if (options.smart) {
+        if (field.endsWith("__label")) continue;
+        const lm = /^(.+)__(.+)$/.exec(field);
+        if (lm && lm[2] !== "label" && i18nBases.has(lm[1])) {
+          const base = lm[1];
+          const coerced2 = coerceXlsxCell(value, types[base]);
+          if (coerced2 !== void 0 && coerced2 !== "") {
+            const map = record[base] ?? {};
+            map[lm[2]] = coerced2;
+            record[base] = map;
+            hasAny = true;
+          }
+          continue;
+        }
+        if (i18nBases.has(field)) continue;
+      }
       const coerced = coerceXlsxCell(value, types[field]);
       if (coerced !== void 0) {
         const invMap = invertMaps.get(field);
@@ -935,11 +1157,14 @@ function excelSerialToMs(serial) {
   download,
   formula,
   fromBytes,
+  inferSchema,
   readXlsx,
   styled,
   toBytes,
   toBytesFromCollection,
+  toBytesMultiVault,
   write,
-  writeXlsx
+  writeXlsx,
+  zodSourceFor
 });
 //# sourceMappingURL=index.cjs.map