@monlite/core 0.6.0 → 0.7.0

package/README.md

@@ -379,8 +379,10 @@ createDb("./app.db", { verbose: (sql) => console.log(sql) }); // see json_extrac
 > **Rule of thumb:** unknown/flexible shape → document (JSON); known/stable shape
 > with heavy joins, reporting, or external SQL tooling → structured (native columns).
 
-> Note: structured collections are not yet covered by `@monlite/sync` (document
-> collections are) — that's planned follow-up work.
+> Both document and structured collections are syncable via
+> [`@monlite/sync`](#sync--local-first). To sync a structured collection, open it
+> with its `schema` on every node before syncing (so each side knows the native
+> columns).
 
 ---
 

package/dist/index.cjs

@@ -239,9 +239,7 @@ function cmp(expr, op, v, ctx) {
 }
 function inExpr(expr, arr, ctx, negate) {
   if (!Array.isArray(arr)) {
-    throw new MonliteQueryError(
-      `${negate ? "notIn" : "in"} expects an array`
-    );
+    throw new MonliteQueryError(`${negate ? "notIn" : "in"} expects an array`);
   }
   if (arr.length === 0) return negate ? "1" : "0";
   const placeholders = arr.map((v) => {
@@ -371,7 +369,8 @@ function applyUpdate(doc, data) {
   }
   const ops = data;
   if (ops.$set) {
-    for (const [path, value] of Object.entries(ops.$set)) setPath(next, path, value);
+    for (const [path, value] of Object.entries(ops.$set))
+      setPath(next, path, value);
   }
   if (ops.$inc) {
     for (const [path, by] of Object.entries(ops.$inc)) {
@@ -492,7 +491,11 @@ function buildHaving(having, params, columns) {
     if (!selection) continue;
     for (const field of Object.keys(selection)) {
       parts.push(
-        ...comparisonSql(`${fn}(${fieldExpr(field, columns)})`, selection[field], params)
+        ...comparisonSql(
+          `${fn}(${fieldExpr(field, columns)})`,
+          selection[field],
+          params
+        )
       );
     }
   }
@@ -520,7 +523,11 @@ function groupBy(ctx, args) {
     groupCols.push({ alias, field });
   });
   selects.push(`COUNT(*) AS agg_count`);
-  const { selects: accSelects, cols } = buildAccumulators(args, ctx.onPath, ctx.columns);
+  const { selects: accSelects, cols } = buildAccumulators(
+    args,
+    ctx.onPath,
+    ctx.columns
+  );
   selects.push(...accSelects);
   let sql = `SELECT ${selects.join(", ")} FROM "${ctx.table}" WHERE ${where} GROUP BY ${groupExprs.join(", ")}`;
   if (args.having) {
@@ -649,7 +656,8 @@ var Collection = class {
         let line = `"${field}" ${sqliteType(def.type)}`;
         if (def.notNull) line += " NOT NULL";
         if (def.unique) line += " UNIQUE";
-        if (def.default !== void 0) line += ` DEFAULT ${formatDefault(def.default)}`;
+        if (def.default !== void 0)
+          line += ` DEFAULT ${formatDefault(def.default)}`;
         if (def.references) line += ` REFERENCES ${def.references}`;
         lines.push(line);
       }
@@ -713,7 +721,12 @@ var Collection = class {
     const now = Date.now();
     const id = input._id != null ? String(input._id) : objectId();
     const doc = stripSystem(input);
-    const returned = { ...doc, _id: id, created_at: now, updated_at: now };
+    const returned = {
+      ...doc,
+      _id: id,
+      created_at: now,
+      updated_at: now
+    };
     if (this.mode === "document") {
       return {
         _id: id,
@@ -765,9 +778,65 @@ var Collection = class {
     ];
     return { setSql: setParts.join(", "), values };
   }
-  /** Sync store, but only for document collections (structured sync is future work). */
+  /** Sync store for recording local changes (both document and structured). */
   get recorder() {
-    return this.mode === "document" ? this.mon.$sync : void 0;
+    return this.mon.$sync;
+  }
+  /** @internal Read a full document by id (mode-aware), synchronously. */
+  getRaw(id) {
+    this.ensureTable();
+    const row = this.db.prepare(`SELECT * FROM "${this.name}" WHERE _id = ?`).get(id);
+    return row ? this.rowToDoc(row) : null;
+  }
+  /**
+   * @internal Apply a remote change to storage WITHOUT recording it to the
+   * change feed (the sync store records the `remote` feed row itself). Used by
+   * `@monlite/sync` so structured collections sync correctly through the same
+   * column/overflow split as local writes.
+   */
+  applyRemoteWrite(op, id, doc, ts) {
+    this.ensureTable();
+    if (op === "delete") {
+      this.db.prepare(`DELETE FROM "${this.name}" WHERE _id = ?`).run(id);
+      return;
+    }
+    const clean = stripSystem(doc ?? {});
+    const createdAt = typeof doc?.created_at === "number" ? doc.created_at : ts;
+    if (this.mode === "document") {
+      this.db.prepare(
+        `INSERT INTO "${this.name}" (_id, data, created_at, updated_at) VALUES (?, ?, ?, ?)
+           ON CONFLICT(_id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`
+      ).run(id, JSON.stringify(clean), createdAt, ts);
+      return;
+    }
+    const overflow = {};
+    const colValues = {};
+    for (const [k, v] of Object.entries(clean)) {
+      if (this.columns.has(k)) colValues[k] = v;
+      else overflow[k] = v;
+    }
+    const cols = [
+      "_id",
+      "created_at",
+      "updated_at",
+      "data",
+      ...this.columnOrder
+    ];
+    const values = [
+      id,
+      createdAt,
+      ts,
+      JSON.stringify(overflow),
+      ...this.columnOrder.map(
+        (c) => c in colValues ? this.encodeColumn(c, colValues[c]) : null
+      )
+    ];
+    const colList = cols.map((c) => `"${c}"`).join(", ");
+    const placeholders = cols.map(() => "?").join(", ");
+    const updateSet = cols.filter((c) => c !== "_id" && c !== "created_at").map((c) => `"${c}" = excluded."${c}"`).join(", ");
+    this.db.prepare(
+      `INSERT INTO "${this.name}" (${colList}) VALUES (${placeholders}) ON CONFLICT(_id) DO UPDATE SET ${updateSet}`
+    ).run(...values);
   }
   /* ----------------------------- create ----------------------------- */
   async create(args) {
@@ -996,7 +1065,12 @@ var Collection = class {
     this.ensureTable();
     return this.guard(
       () => aggregate(
-        { db: this.db, table: this.name, onPath: this.trackPath, columns: this.columns },
+        {
+          db: this.db,
+          table: this.name,
+          onPath: this.trackPath,
+          columns: this.columns
+        },
         args
       )
     );
@@ -1005,7 +1079,12 @@ var Collection = class {
     this.ensureTable();
     return this.guard(
       () => groupBy(
-        { db: this.db, table: this.name, onPath: this.trackPath, columns: this.columns },
+        {
+          db: this.db,
+          table: this.name,
+          onPath: this.trackPath,
+          columns: this.columns
+        },
         args
       )
     );
@@ -1253,12 +1332,14 @@ function stripSystem2(obj) {
   return rest;
 }
 var SyncStore = class {
-  constructor(db, nodeId) {
+  constructor(db, nodeId, mon) {
     this.db = db;
+    this.mon = mon;
     this.init();
     this.nodeId = this.resolveNodeId(nodeId);
   }
   db;
+  mon;
   nodeId;
   versionSeq = 0;
   init() {
@@ -1293,7 +1374,9 @@ var SyncStore = class {
   }
   resolveNodeId(explicit) {
     if (explicit) {
-      this.db.prepare(`INSERT OR REPLACE INTO _monlite_meta (key, value) VALUES ('nodeId', ?)`).run(explicit);
+      this.db.prepare(
+        `INSERT OR REPLACE INTO _monlite_meta (key, value) VALUES ('nodeId', ?)`
+      ).run(explicit);
       return explicit;
     }
     const row = this.db.prepare(`SELECT value FROM _monlite_meta WHERE key = 'nodeId'`).get();
@@ -1408,6 +1491,9 @@ var SyncStore = class {
         );
       }
       if (winner !== "remote") {
+        if (localVersion !== null) {
+          this.recordLocal(change.collection, change._id, "upsert", Date.now());
+        }
         return { applied: false, conflict: localVersion !== null, winner };
       }
       this.applyData(change);
@@ -1421,24 +1507,31 @@ var SyncStore = class {
         change.version,
         versionTs(change.version)
       );
-      return { applied: true, conflict: localVersion !== null, winner: "remote" };
+      return {
+        applied: true,
+        conflict: localVersion !== null,
+        winner: "remote"
+      };
     });
   }
   applyData(change) {
-    const { collection: coll, _id, op } = change;
+    const ts = versionTs(change.version);
+    if (this.mon) {
+      this.mon.collection(change.collection).applyRemoteWrite(change.op, change._id, change.doc, ts);
+      return;
+    }
+    const coll = change.collection;
     this.ensureCollTable(coll);
-    if (op === "delete") {
-      this.db.prepare(`DELETE FROM "${coll}" WHERE _id = ?`).run(_id);
+    if (change.op === "delete") {
+      this.db.prepare(`DELETE FROM "${coll}" WHERE _id = ?`).run(change._id);
       return;
     }
     const doc = change.doc ?? {};
-    const data = JSON.stringify(stripSystem2(doc));
-    const ts = versionTs(change.version);
     const createdAt = typeof doc.created_at === "number" ? doc.created_at : ts;
     this.db.prepare(
       `INSERT INTO "${coll}" (_id, data, created_at, updated_at) VALUES (?, ?, ?, ?)
          ON CONFLICT(_id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`
-    ).run(_id, data, createdAt, ts);
+    ).run(change._id, JSON.stringify(stripSystem2(doc)), createdAt, ts);
   }
   /**
    * Latest change per document with `seq` greater than the given watermark,
@@ -1495,6 +1588,7 @@ var SyncStore = class {
     this.db.transaction(() => {
       for (const coll of collections) {
         assertName(coll);
+        if (!this.tableExists(coll)) continue;
         const docs = this.db.prepare(`SELECT _id, updated_at FROM "${coll}"`).all();
         for (const d of docs) {
           if (this.currentVersion(coll, d._id) !== null) continue;
@@ -1540,7 +1634,14 @@ var SyncStore = class {
     this.db.prepare(
       `INSERT INTO _monlite_conflicts (coll, doc_id, local_version, remote_version, winner, ts)
          VALUES (?, ?, ?, ?, ?, ?)`
-    ).run(coll, id, localVersion, remoteVersion, winner, versionTs(remoteVersion));
+    ).run(
+      coll,
+      id,
+      localVersion,
+      remoteVersion,
+      winner,
+      versionTs(remoteVersion)
+    );
   }
   conflicts() {
     const rows = this.db.prepare(
@@ -1559,6 +1660,8 @@ var SyncStore = class {
   /* ------------------------------ helpers ------------------------------- */
   readDoc(coll, id) {
     assertName(coll);
+    if (this.mon) return this.mon.collection(coll).getRaw(id);
+    if (!this.tableExists(coll)) return null;
     const row = this.db.prepare(
       `SELECT _id, data, created_at, updated_at FROM "${coll}" WHERE _id = ?`
     ).get(id);
@@ -1569,6 +1672,9 @@ var SyncStore = class {
     doc.updated_at = row.updated_at;
     return doc;
   }
+  tableExists(name) {
+    return this.db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?`).get(name) != null;
+  }
   ensureCollTable(coll) {
     assertName(coll);
     this.db.exec(
@@ -1625,7 +1731,7 @@ var Monlite = class {
       options.autoIndexAfter ?? 10
     );
     if (options.sync) {
-      this.$sync = new SyncStore(this.driver, options.nodeId);
+      this.$sync = new SyncStore(this.driver, options.nodeId, this);
     }
   }
   /** Stable node id for LWW tie-breaking (only when sync is enabled). */