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

package/dist/index.d.ts

@@ -154,6 +154,30 @@ interface ReadXlsxResult {
  */
 declare function readXlsx(bytes: Uint8Array): Promise<ReadXlsxResult>;
 
+type InferredType = 'string' | 'number' | 'boolean' | 'date';
+interface InferredField {
+    readonly type: InferredType;
+    /** Target collection (sheet) name when this field looks like a foreign key. */
+    readonly references?: string;
+}
+interface InferredCollection {
+    readonly idField: string;
+    readonly fields: Record<string, InferredField>;
+}
+interface InferredSchema {
+    readonly collections: Record<string, InferredCollection>;
+}
+/**
+ * Infer a {@link InferredSchema} from an `.xlsx` byte stream. Sheets whose name
+ * starts with `_` (our smart-export meta sheets) are skipped; pass `skipSheets`
+ * to exclude more (e.g. summary sheets).
+ */
+declare function inferSchema(bytes: Uint8Array, options?: {
+    skipSheets?: readonly string[];
+}): Promise<InferredSchema>;
+/** Emit a Zod schema snippet (guidance) from an {@link InferredSchema}. */
+declare function zodSourceFor(schema: InferredSchema): string;
+
 /**
  * **@noy-db/as-xlsx** — Excel spreadsheet plaintext export for noy-db.
  *
@@ -274,6 +298,13 @@ interface AsXlsxOptions {
     readonly sheets: readonly AsXlsxSheetOptions[];
     /** Smart mode only: groupBy summary sheets (live SUMIFS/COUNTIFS/AVERAGEIFS). */
     readonly summaries?: readonly AsXlsxSummarySpec[];
+    /**
+     * Smart mode only: summary formula dialect. `'excel'` (default) emits
+     * cross-compatible per-row SUMIFS/COUNTIFS/AVERAGEIFS. `'sheets'` emits a
+     * single Google-Sheets `QUERY` formula per summary — **Sheets-only** (QUERY
+     * errors in Excel); use when the target is Google Sheets.
+     */
+    readonly dialect?: 'excel' | 'sheets';
     /**
      * Smart-workbook mode (#414). Emits a relational workbook instead of a flat
      * dump:
@@ -372,6 +403,14 @@ interface AsXlsxImportOptions {
      * Unknown labels (no match in any locale) pass through as-is.
      */
     readonly dicts?: Readonly<Record<string, readonly DictEntry[]>>;
+    /**
+     * Read a sheet produced by smart export (#414 P4). Reverses the smart layout:
+     * reconstructs i18n fields from their per-locale columns (`<f>__<loc>` →
+     * `{ loc: value }`), and drops derived columns — the i18n display column and
+     * every `<f>__label` (FK/dict) formula column. Code columns (the real values)
+     * pass through. Maps onto the existing collection schema (Mode A).
+     */
+    readonly smart?: boolean;
 }
 interface AsXlsxImportPlan {
     readonly plan: VaultDiff;
@@ -402,4 +441,4 @@ interface AsXlsxImportPlan {
  */
 declare function fromBytes(vault: Vault, bytes: Uint8Array, options: AsXlsxImportOptions): Promise<AsXlsxImportPlan>;
 
-export { type AsXlsxDownloadOptions, type AsXlsxImportOptions, type AsXlsxImportPlan, type AsXlsxOptions, type AsXlsxSheetOptions, type AsXlsxSummaryAggregate, type AsXlsxSummarySpec, type AsXlsxWriteOptions, type ImportPolicy, type ReadXlsxResult, type ReadXlsxRow, type ReadXlsxSheet, XlsxDictAmbiguityError, type XlsxFormulaCell, type XlsxRow, type XlsxSheet, type XlsxStyledCell, type XlsxValidation, colLetter, download, formula, fromBytes, readXlsx, styled, toBytes, toBytesFromCollection, write, writeXlsx };
+export { type AsXlsxDownloadOptions, type AsXlsxImportOptions, type AsXlsxImportPlan, type AsXlsxOptions, type AsXlsxSheetOptions, type AsXlsxSummaryAggregate, type AsXlsxSummarySpec, type AsXlsxWriteOptions, type ImportPolicy, type InferredCollection, type InferredField, type InferredSchema, type InferredType, type ReadXlsxResult, type ReadXlsxRow, type ReadXlsxSheet, XlsxDictAmbiguityError, type XlsxFormulaCell, type XlsxRow, type XlsxSheet, type XlsxStyledCell, type XlsxValidation, colLetter, download, formula, fromBytes, inferSchema, readXlsx, styled, toBytes, toBytesFromCollection, write, writeXlsx, zodSourceFor };

package/dist/index.js

@@ -419,6 +419,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
 import { diffVault } from "@noy-db/hub";
 async function toBytesFromCollection(vault, collectionName) {
@@ -636,6 +722,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);
@@ -643,6 +730,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) {
@@ -772,6 +879,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];
@@ -780,6 +894,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);
@@ -888,11 +1018,13 @@ export {
   download,
   formula,
   fromBytes,
+  inferSchema,
   readXlsx,
   styled,
   toBytes,
   toBytesFromCollection,
   write,
-  writeXlsx
+  writeXlsx,
+  zodSourceFor
 };
 //# sourceMappingURL=index.js.map