js-bao 0.5.1 → 0.5.2

package/dist/cloudflare-do.cjs

@@ -256,21 +256,36 @@ var init_CursorManager = __esm({
         return fields;
       }
       /**
-       * Build ORDER BY clause from sort specification
+       * Build ORDER BY clause from sort specification.
+       *
+       * `direction` is the pagination direction (1 = forward, -1 = backward).
+       * For backward pagination each field's effective ORDER BY direction is
+       * reversed so the cursor's flipped inequality (built by
+       * `buildPaginationConditions`) returns the page adjacent to the cursor,
+       * not the globally smallest/largest window. Without this,
+       * `field < cursor ... ORDER BY field ASC LIMIT n` returns the n smallest
+       * rows overall instead of the n rows just below the cursor.
+       *
+       * The returned `directions` array carries the *declared* per-field sort
+       * directions (unaffected by `direction`) — `buildPaginationConditions`
+       * needs the declared directions to pick each field's comparison operator.
        */
-      static buildOrderClause(sort, fieldFormatter = (field) => field) {
+      static buildOrderClause(sort, fieldFormatter = (field) => field, direction = 1) {
         const fields = this.extractSortFields(sort);
         const clauses = [];
         const directions = [];
+        const sqlDir = (declared) => {
+          const effective = direction === -1 ? declared === 1 ? -1 : 1 : declared;
+          return effective === 1 ? "ASC" : "DESC";
+        };
         if (sort && Object.keys(sort).length > 0) {
           for (const [field, dir] of Object.entries(sort)) {
-            const sqlDirection = dir === 1 ? "ASC" : "DESC";
-            clauses.push(`${fieldFormatter(field)} ${sqlDirection}`);
+            clauses.push(`${fieldFormatter(field)} ${sqlDir(dir)}`);
             directions.push(dir);
           }
         }
         if (!sort || !sort.hasOwnProperty("id")) {
-          clauses.push(`${fieldFormatter("id")} ASC`);
+          clauses.push(`${fieldFormatter("id")} ${sqlDir(1)}`);
           directions.push(1);
         } else if (sort && sort.hasOwnProperty("id")) {
           directions.push(sort["id"]);
@@ -293,18 +308,27 @@ var init_CursorManager = __esm({
       /**
        * Generate next and previous cursors from result set
        */
-      static generateResultCursors(results, sortFields, _requestedDirection, hasMore, isFirstPage = false) {
+      static generateResultCursors(results, sortFields, requestedDirection, hasMore, isFirstPage = false) {
         if (results.length === 0) {
           return {};
         }
         const cursors = {};
         if (hasMore && results.length > 0) {
           const lastResult = results[results.length - 1];
-          cursors.nextCursor = this.generateCursor(lastResult, sortFields, 1);
+          cursors.nextCursor = this.generateCursor(
+            lastResult,
+            sortFields,
+            requestedDirection
+          );
         }
         if (results.length > 0 && !isFirstPage) {
           const firstResult = results[0];
-          cursors.prevCursor = this.generateCursor(firstResult, sortFields, -1);
+          const opposite = requestedDirection === 1 ? -1 : 1;
+          cursors.prevCursor = this.generateCursor(
+            firstResult,
+            sortFields,
+            opposite
+          );
         }
         return cursors;
       }
@@ -395,6 +419,31 @@ var init_DocumentQueryTranslator = __esm({
   }
 });
 
+// src/models/writeLifecycle.ts
+function registerFunctionDefaultGenerator(name, fn) {
+  FUNCTION_DEFAULT_GENERATORS.set(name, fn);
+}
+var Y3, import_ulid2, KNOWN_FIELD_TYPE_MAP, KNOWN_FIELD_TYPES, FUNCTION_DEFAULT_GENERATORS, UNKNOWN_FUNCTION_DEFAULT;
+var init_writeLifecycle = __esm({
+  "src/models/writeLifecycle.ts"() {
+    "use strict";
+    Y3 = __toESM(require("yjs"), 1);
+    import_ulid2 = require("ulid");
+    KNOWN_FIELD_TYPE_MAP = {
+      string: true,
+      number: true,
+      boolean: true,
+      date: true,
+      id: true,
+      stringset: true
+    };
+    KNOWN_FIELD_TYPES = new Set(Object.keys(KNOWN_FIELD_TYPE_MAP));
+    FUNCTION_DEFAULT_GENERATORS = /* @__PURE__ */ new Map();
+    registerFunctionDefaultGenerator("generate_ulid", () => (0, import_ulid2.ulid)());
+    UNKNOWN_FUNCTION_DEFAULT = "$unknown_function";
+  }
+});
+
 // src/models/metaSync.ts
 function inferFieldType(value) {
   if (isStringSetYMap(value)) return "stringset";
@@ -416,7 +465,10 @@ function encodeDefault(value) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "function") {
     const name = KNOWN_FUNCTION_DEFAULTS.get(value);
-    return name ? `$${name}` : "$unknown_function";
+    return name ? `$${name}` : UNKNOWN_FUNCTION_DEFAULT;
+  }
+  if (typeof value === "string" && value.startsWith("$")) {
+    return `$${value}`;
   }
   return value;
 }
@@ -442,7 +494,7 @@ function syncModelMeta(yDoc, modelName, schema) {
   if (compoundConstraints.length > 0) {
     let constraints = meta.get("_constraints");
     if (!constraints) {
-      constraints = new Y3.Map();
+      constraints = new Y4.Map();
       meta.set("_constraints", constraints);
     }
     for (const constraint of compoundConstraints) {
@@ -453,7 +505,7 @@ function syncModelMeta(yDoc, modelName, schema) {
   if (relationships && Object.keys(relationships).length > 0) {
     let rels = meta.get("_relationships");
     if (!rels) {
-      rels = new Y3.Map();
+      rels = new Y4.Map();
       meta.set("_relationships", rels);
     }
     for (const [relName, relConfig] of Object.entries(relationships)) {
@@ -465,7 +517,7 @@ function syncModelMeta(yDoc, modelName, schema) {
 function syncFieldMeta(metaMap, fieldName, fieldOpts) {
   let fieldMeta = metaMap.get(fieldName);
   if (!fieldMeta) {
-    fieldMeta = new Y3.Map();
+    fieldMeta = new Y4.Map();
     metaMap.set(fieldName, fieldMeta);
   }
   setIfChanged(fieldMeta, "type", fieldOpts.type);
@@ -482,7 +534,7 @@ function syncFieldMeta(metaMap, fieldName, fieldOpts) {
 function syncConstraintMeta(constraintsMap, constraint) {
   let cMeta = constraintsMap.get(constraint.name);
   if (!cMeta) {
-    cMeta = new Y3.Map();
+    cMeta = new Y4.Map();
     constraintsMap.set(constraint.name, cMeta);
   }
   setIfChanged(cMeta, "type", "unique");
@@ -492,7 +544,7 @@ function syncConstraintMeta(constraintsMap, constraint) {
 function syncRelationshipMeta(relsMap, relName, relConfig) {
   let relMeta = relsMap.get(relName);
   if (!relMeta) {
-    relMeta = new Y3.Map();
+    relMeta = new Y4.Map();
     relsMap.set(relName, relMeta);
   }
   for (const [key, value] of Object.entries(relConfig)) {
@@ -507,7 +559,7 @@ function syncInferredMeta(yDoc, modelName, recordData) {
     if (fieldName.startsWith("_")) continue;
     let fieldMeta = meta.get(fieldName);
     if (!fieldMeta) {
-      fieldMeta = new Y3.Map();
+      fieldMeta = new Y4.Map();
       meta.set(fieldName, fieldMeta);
     }
     if (!fieldMeta.has("type")) {
@@ -523,34 +575,49 @@ function setIfChanged(map, key, value) {
     map.set(key, value);
   }
 }
-var Y3, KNOWN_FUNCTION_DEFAULTS, _syncedCache;
+var Y4, KNOWN_FUNCTION_DEFAULTS, _syncedCache;
 var init_metaSync = __esm({
   "src/models/metaSync.ts"() {
     "use strict";
-    Y3 = __toESM(require("yjs"), 1);
+    Y4 = __toESM(require("yjs"), 1);
     init_yjsValues();
+    init_writeLifecycle();
     KNOWN_FUNCTION_DEFAULTS = /* @__PURE__ */ new WeakMap();
     _syncedCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
+// src/utils/uniqueIndex.ts
+function fieldUniqueConstraintName(modelName, fieldName) {
+  return `${modelName}_${fieldName}_unique`;
+}
+var Y5;
+var init_uniqueIndex = __esm({
+  "src/utils/uniqueIndex.ts"() {
+    "use strict";
+    Y5 = __toESM(require("yjs"), 1);
+  }
+});
+
 // src/models/BaseModel.ts
 function generateULID() {
-  return (0, import_ulid2.ulid)();
+  return (0, import_ulid3.ulid)();
 }
-var Y4, import_ulid2;
+var Y6, import_ulid3;
 var init_BaseModel = __esm({
   "src/models/BaseModel.ts"() {
     "use strict";
-    Y4 = __toESM(require("yjs"), 1);
-    import_ulid2 = require("ulid");
+    Y6 = __toESM(require("yjs"), 1);
+    import_ulid3 = require("ulid");
     init_StringSet();
     init_documentTypes();
     init_DocumentQueryTranslator();
     init_CursorManager();
     init_sql();
     init_metaSync();
+    init_writeLifecycle();
     init_yjsValues();
+    init_uniqueIndex();
     registerFunctionDefault(generateULID, "generate_ulid");
   }
 });
@@ -578,6 +645,7 @@ __export(cloudflare_do_exports, {
   DurableObjectEngine: () => DurableObjectEngine,
   JsonQueryTranslator: () => JsonQueryTranslator,
   JsonSchemaDDL: () => JsonSchemaDDL,
+  PROJECTED_JSON_ALIAS_PREFIX: () => PROJECTED_JSON_ALIAS_PREFIX,
   buildSafeAlias: () => buildSafeAlias,
   checkAutoStampsReservedFields: () => checkAutoStampsReservedFields,
   checkReservedFieldName: () => checkReservedFieldName,
@@ -590,6 +658,8 @@ __export(cloudflare_do_exports, {
   handleRequest: () => handleRequest,
   inferFieldType: () => inferFieldType,
   loadSchemaFromTomlString: () => loadSchemaFromTomlString,
+  parseRecordRow: () => parseRecordRow,
+  projectedJsonAlias: () => projectedJsonAlias,
   registerFunctionDefault: () => registerFunctionDefault,
   schemaToToml: () => schemaToToml,
   syncInferredMeta: () => syncInferredMeta,
@@ -1605,6 +1675,45 @@ var DurableObjectEngine = class extends JsonSchemaEngine {
 init_queryTypes();
 init_CursorManager();
 init_sql();
+
+// src/query/recordRow.ts
+var PROJECTED_JSON_ALIAS_PREFIX = "_json_";
+function projectedJsonAlias(fieldName) {
+  return `${PROJECTED_JSON_ALIAS_PREFIX}${fieldName}`;
+}
+function parseRecordRow(row) {
+  const { _id, _type, _data, ...rest } = row;
+  let parsed = {};
+  if (_data) {
+    try {
+      parsed = JSON.parse(_data);
+    } catch (e) {
+      console.warn("Failed to parse _data:", e);
+    }
+  }
+  return { id: _id, type: _type, ...parsed, ...decodeProjectedColumns(rest) };
+}
+function decodeProjectedColumns(columns) {
+  const decoded = {};
+  for (const [column, value] of Object.entries(columns)) {
+    if (!column.startsWith(PROJECTED_JSON_ALIAS_PREFIX)) {
+      decoded[column] = value;
+      continue;
+    }
+    decoded[column.slice(PROJECTED_JSON_ALIAS_PREFIX.length)] = parseJsonColumn(value);
+  }
+  return decoded;
+}
+function parseJsonColumn(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// src/query/JsonQueryTranslator.ts
 init_patterns();
 var SYSTEM_FIELDS = /* @__PURE__ */ new Set(["id", "type"]);
 var JsonQueryTranslator = class {
@@ -1649,7 +1758,8 @@ var JsonQueryTranslator = class {
     const whereClause = this.translateFilter(filter);
     const orderClause = CursorManager.buildOrderClause(
       options?.sort,
-      (field) => this.getFieldSql(field)
+      (field) => this.getFieldSql(field),
+      options?.direction || 1
     );
     const limitClause = this.buildLimitClause(options);
     const paginationClause = this.buildPaginationClause(
@@ -2100,7 +2210,7 @@ var JsonQueryTranslator = class {
       for (const field of includeFields) {
         if (field === "id" || field === "type") continue;
         selectParts.push(
-          `json_extract(_data, '$.${field}') AS ${quoteIdentifier(field)}`
+          `_data -> '$.${field}' AS ${quoteIdentifier(projectedJsonAlias(field))}`
         );
       }
       return selectParts.join(", ");
@@ -2287,6 +2397,13 @@ var JsonQueryTranslator = class {
 init_CursorManager();
 init_sql();
 var import_ulid = require("ulid");
+var AtomicBatchAbort = class extends Error {
+  constructor(failedIndex) {
+    super(`atomic batch aborted at operation ${failedIndex}`);
+    this.failedIndex = failedIndex;
+    this.name = "AtomicBatchAbort";
+  }
+};
 function checkReservedFieldName(fieldName) {
   if (fieldName === "id") return null;
   if (fieldName === "type") {
@@ -2331,6 +2448,35 @@ function applyAutoStamps(data, autoStamps, isNew) {
     }
   }
 }
+function collectAppliedStamps(data, autoStamps, isNew) {
+  if (!autoStamps || !data) return void 0;
+  const stamps = {};
+  const take = (fields) => {
+    if (!fields) return;
+    for (const field of fields) {
+      const value = data[field];
+      if (typeof value === "number" && Number.isFinite(value)) {
+        stamps[field] = value;
+      }
+    }
+  };
+  if (isNew) take(autoStamps.create);
+  take(autoStamps.update);
+  return Object.keys(stamps).length > 0 ? stamps : void 0;
+}
+function collectAppliedValues(data, fieldNames) {
+  if (!data || !fieldNames || fieldNames.length === 0) return void 0;
+  const out = {};
+  for (const name of fieldNames) {
+    const value = data[name];
+    if (value !== void 0) out[name] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function mergeAppliedFields(stamps, applied) {
+  if (!stamps && !applied) return void 0;
+  return { ...stamps ?? {}, ...applied ?? {} };
+}
 function createDatabaseDO(config = {}) {
   const hooks = config.hooks;
   return class DocumentDO {
@@ -2488,6 +2634,16 @@ function createDatabaseDO(config = {}) {
         hasMore,
         isFirstPage
       );
+      if (options?.projection && Object.keys(options.projection).length > 0) {
+        const isExclusion = Object.values(options.projection).some(
+          (v) => v === 0
+        );
+        if (isExclusion) {
+          data = data.map(
+            (rec) => this._applyProjection(rec, options.projection)
+          );
+        }
+      }
       const response = {
         data,
         hasMore,
@@ -2590,6 +2746,7 @@ function createDatabaseDO(config = {}) {
       }
       const isNew = !this._engine.recordExists(modelName, id);
       applyAutoStamps(data, autoStamps, isNew);
+      let hookAppliedNames;
       if (hooks?.beforeSave) {
         const ctx = {
           modelName,
@@ -2605,6 +2762,7 @@ function createDatabaseDO(config = {}) {
         if (!result.allow) {
           return this._errorResponse(result.reason || "Save denied", 403);
         }
+        hookAppliedNames = result.serverAppliedFieldNames;
       }
       const existingForUnique = this._engine.execSqlSync(
         "SELECT _data FROM records WHERE _id = ? AND _type = ?",
@@ -2634,6 +2792,11 @@ function createDatabaseDO(config = {}) {
       }
       this._engine.trackModelFields(modelName, data);
       const response = { success: true, id };
+      const appliedFields = mergeAppliedFields(
+        collectAppliedStamps(data, autoStamps, isNew),
+        collectAppliedValues(data, hookAppliedNames)
+      );
+      if (appliedFields) response.appliedFields = appliedFields;
       return Response.json(response);
     }
     /** @internal — Partial update: merge provided fields into existing record */
@@ -2663,6 +2826,7 @@ function createDatabaseDO(config = {}) {
         );
       }
       applyAutoStamps(data, autoStamps, false);
+      let hookAppliedNames;
       if (hooks?.beforeSave) {
         const ctx = {
           modelName,
@@ -2678,6 +2842,7 @@ function createDatabaseDO(config = {}) {
         if (!result.allow) {
           return this._errorResponse(result.reason || "Save denied", 403);
         }
+        hookAppliedNames = result.serverAppliedFieldNames;
       }
       const existing = this._engine.execSqlSync(
         "SELECT _data FROM records WHERE _id = ? AND _type = ?",
@@ -2701,6 +2866,11 @@ function createDatabaseDO(config = {}) {
       }
       this._engine.trackModelFields(modelName, data);
       const response = { success: true, id };
+      const appliedFields = mergeAppliedFields(
+        collectAppliedStamps(data, autoStamps, false),
+        collectAppliedValues(data, hookAppliedNames)
+      );
+      if (appliedFields) response.appliedFields = appliedFields;
       return Response.json(response);
     }
     /** @internal */
@@ -2742,7 +2912,7 @@ function createDatabaseDO(config = {}) {
     /** @internal — Execute multiple save/patch/delete operations in a single transaction */
     async _handleBatch(request, docId) {
       const body = await request.json();
-      const { operations } = body;
+      const { operations, atomic = false } = body;
       if (!operations || !Array.isArray(operations) || operations.length === 0) {
         return this._errorResponse("operations array is required and must not be empty", 400);
       }
@@ -2750,6 +2920,8 @@ function createDatabaseDO(config = {}) {
       const resolvedBatchIds = /* @__PURE__ */ new Map();
       const opErrors = /* @__PURE__ */ new Map();
       const batchCreatedIds = /* @__PURE__ */ new Set();
+      const batchIsNew = /* @__PURE__ */ new Map();
+      const batchAppliedNames = /* @__PURE__ */ new Map();
       for (let i = 0; i < operations.length; i++) {
         const op = operations[i];
         if (!op.modelName || !op.id && !(op.op === "save" && op.upsertOn) || !op.op) {
@@ -2823,6 +2995,7 @@ function createDatabaseDO(config = {}) {
           if (op.op === "save" && isNew && effectiveId) {
             batchCreatedIds.add(`${op.modelName}/${effectiveId}`);
           }
+          batchIsNew.set(i, isNew);
           applyAutoStamps(op.data, op.autoStamps, isNew);
           if (hooks?.beforeSave) {
             const ctx = {
@@ -2838,6 +3011,8 @@ function createDatabaseDO(config = {}) {
             const result = await hooks.beforeSave(ctx);
             if (!result.allow) {
               hookDenials.set(i, result.reason || "Save denied");
+            } else if (result.serverAppliedFieldNames) {
+              batchAppliedNames.set(i, result.serverAppliedFieldNames);
             }
           }
         } else if (op.op === "delete") {
@@ -2886,205 +3061,263 @@ function createDatabaseDO(config = {}) {
       }
       const results = [];
       const fieldsToTrack = [];
-      this._engine.transactionSync(() => {
-        for (let i = 0; i < operations.length; i++) {
-          const op = operations[i];
-          if (hookDenials.has(i)) {
-            const effectiveId = resolvedBatchIds.get(i) || op.id || "";
-            results.push({
-              success: false,
-              id: effectiveId,
-              error: hookDenials.get(i)
-            });
-            continue;
-          }
-          if (opErrors.has(i)) {
-            results.push({
-              success: false,
-              id: op.id || "",
-              error: opErrors.get(i)
-            });
-            continue;
-          }
-          const conditionId = resolvedBatchIds.get(i) || op.id;
-          if (op.condition && !this._checkCondition(op.modelName, conditionId, op.condition)) {
-            results.push({
-              success: false,
-              id: conditionId,
-              error: `Condition not met for ${op.modelName}/${conditionId}`
-            });
-            continue;
-          }
-          if (op.op === "save") {
-            let opId = resolvedBatchIds.get(i) || op.id;
-            if (op.ifNotExists && this._engine.recordExists(op.modelName, opId)) {
-              results.push({
-                success: false,
-                id: opId,
-                error: `Record ${op.modelName}/${opId} already exists`
+      const pushFailure = (index, failure) => {
+        results.push({
+          success: false,
+          id: failure.id,
+          error: failure.error,
+          status: failure.status,
+          code: failure.code
+        });
+        if (atomic) throw new AtomicBatchAbort(index);
+      };
+      try {
+        this._engine.transactionSync(() => {
+          for (let i = 0; i < operations.length; i++) {
+            const op = operations[i];
+            if (hookDenials.has(i)) {
+              const effectiveId = resolvedBatchIds.get(i) || op.id || "";
+              pushFailure(i, {
+                id: effectiveId,
+                error: hookDenials.get(i),
+                status: 403,
+                code: "HOOK_DENIED"
               });
               continue;
             }
-            if (op.data) {
-              const existingForUnique = this._engine.execSqlSync(
-                "SELECT _data FROM records WHERE _id = ? AND _type = ?",
-                [opId, op.modelName]
-              );
-              let dataForUnique = op.data;
-              if (existingForUnique.length > 0) {
-                const existingData = JSON.parse(existingForUnique[0]._data);
-                dataForUnique = { ...existingData, ...op.data };
-              }
-              const violation = this._engine.checkUniqueConstraints(
-                op.modelName,
-                opId,
-                dataForUnique
-              );
-              if (violation) {
-                results.push({
-                  success: false,
+            if (opErrors.has(i)) {
+              pushFailure(i, {
+                id: op.id || "",
+                error: opErrors.get(i),
+                status: 400,
+                code: "VALIDATION_ERROR"
+              });
+              continue;
+            }
+            const conditionId = resolvedBatchIds.get(i) || op.id;
+            if (op.condition && !this._checkCondition(op.modelName, conditionId, op.condition)) {
+              pushFailure(i, {
+                id: conditionId,
+                error: `Condition not met for ${op.modelName}/${conditionId}`,
+                status: 409,
+                code: "CONDITION_NOT_MET"
+              });
+              continue;
+            }
+            if (op.op === "save") {
+              let opId = resolvedBatchIds.get(i) || op.id;
+              if (op.ifNotExists && this._engine.recordExists(op.modelName, opId)) {
+                pushFailure(i, {
                   id: opId,
-                  error: violation
+                  error: `Record ${op.modelName}/${opId} already exists`,
+                  status: 409,
+                  code: "ALREADY_EXISTS"
                 });
                 continue;
               }
-            }
-            if (op.stringSets && Object.keys(op.stringSets).length > 0) {
-              const { id: _id, ...fieldsForJson } = op.data;
-              const jsonFields = { ...fieldsForJson, ...op.stringSets };
-              const dataJson = JSON.stringify(jsonFields);
-              this._engine.execSqlSync(
-                "INSERT INTO records (_id, _type, _data) VALUES (?, ?, ?) ON CONFLICT(_type, _id) DO UPDATE SET _data = json_patch(records._data, excluded._data)",
-                [opId, op.modelName, dataJson]
-              );
-              for (const [fieldName, values] of Object.entries(op.stringSets)) {
-                this._engine.execSqlSync(
-                  "DELETE FROM stringset_index WHERE _type = ? AND _record_id = ? AND field = ?",
-                  [op.modelName, opId, fieldName]
+              if (op.data) {
+                const existingForUnique = this._engine.execSqlSync(
+                  "SELECT _data FROM records WHERE _id = ? AND _type = ?",
+                  [opId, op.modelName]
                 );
-                for (const value of values) {
-                  this._engine.execSqlSync(
-                    "INSERT OR IGNORE INTO stringset_index (_record_id, _type, field, value) VALUES (?, ?, ?, ?)",
-                    [opId, op.modelName, fieldName, value]
-                  );
+                let dataForUnique = op.data;
+                if (existingForUnique.length > 0) {
+                  const existingData = JSON.parse(existingForUnique[0]._data);
+                  dataForUnique = { ...existingData, ...op.data };
                 }
-              }
-            } else {
-              const { id: _id, ...fieldsForJson } = op.data;
-              const dataJson = JSON.stringify(fieldsForJson);
-              this._engine.execSqlSync(
-                "INSERT INTO records (_id, _type, _data) VALUES (?, ?, ?) ON CONFLICT(_type, _id) DO UPDATE SET _data = json_patch(records._data, excluded._data)",
-                [opId, op.modelName, dataJson]
-              );
-            }
-            if (op.data) fieldsToTrack.push({ modelName: op.modelName, data: op.data });
-            results.push({ success: true, id: opId });
-          } else if (op.op === "patch") {
-            if (!this._engine.recordExists(op.modelName, op.id)) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-              continue;
-            }
-            if (op.data) {
-              const existing = this._engine.execSqlSync(
-                "SELECT _data FROM records WHERE _id = ? AND _type = ?",
-                [op.id, op.modelName]
-              );
-              if (existing.length > 0) {
-                const existingData = JSON.parse(existing[0]._data);
-                const mergedData = { ...existingData, ...op.data };
                 const violation = this._engine.checkUniqueConstraints(
                   op.modelName,
-                  op.id,
-                  mergedData
+                  opId,
+                  dataForUnique
                 );
                 if (violation) {
-                  results.push({
-                    success: false,
-                    id: op.id,
-                    error: violation
+                  pushFailure(i, {
+                    id: opId,
+                    error: violation,
+                    status: 409,
+                    code: "UNIQUE_VIOLATION"
                   });
                   continue;
                 }
               }
-            }
-            const found = this._engine.patchRecordRaw(
-              op.modelName,
-              op.id,
-              op.data,
-              op.stringSets
-            );
-            if (!found) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-            } else {
+              if (op.stringSets && Object.keys(op.stringSets).length > 0) {
+                const { id: _id, ...fieldsForJson } = op.data;
+                const jsonFields = { ...fieldsForJson, ...op.stringSets };
+                const dataJson = JSON.stringify(jsonFields);
+                this._engine.execSqlSync(
+                  "INSERT INTO records (_id, _type, _data) VALUES (?, ?, ?) ON CONFLICT(_type, _id) DO UPDATE SET _data = json_patch(records._data, excluded._data)",
+                  [opId, op.modelName, dataJson]
+                );
+                for (const [fieldName, values] of Object.entries(op.stringSets)) {
+                  this._engine.execSqlSync(
+                    "DELETE FROM stringset_index WHERE _type = ? AND _record_id = ? AND field = ?",
+                    [op.modelName, opId, fieldName]
+                  );
+                  for (const value of values) {
+                    this._engine.execSqlSync(
+                      "INSERT OR IGNORE INTO stringset_index (_record_id, _type, field, value) VALUES (?, ?, ?, ?)",
+                      [opId, op.modelName, fieldName, value]
+                    );
+                  }
+                }
+              } else {
+                const { id: _id, ...fieldsForJson } = op.data;
+                const dataJson = JSON.stringify(fieldsForJson);
+                this._engine.execSqlSync(
+                  "INSERT INTO records (_id, _type, _data) VALUES (?, ?, ?) ON CONFLICT(_type, _id) DO UPDATE SET _data = json_patch(records._data, excluded._data)",
+                  [opId, op.modelName, dataJson]
+                );
+              }
               if (op.data) fieldsToTrack.push({ modelName: op.modelName, data: op.data });
+              const saveResult = { success: true, id: opId };
+              const saveApplied = mergeAppliedFields(
+                collectAppliedStamps(
+                  op.data,
+                  op.autoStamps,
+                  batchIsNew.get(i) ?? false
+                ),
+                collectAppliedValues(op.data, batchAppliedNames.get(i))
+              );
+              if (saveApplied) saveResult.appliedFields = saveApplied;
+              results.push(saveResult);
+            } else if (op.op === "patch") {
+              if (!this._engine.recordExists(op.modelName, op.id)) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+                continue;
+              }
+              if (op.data) {
+                const existing = this._engine.execSqlSync(
+                  "SELECT _data FROM records WHERE _id = ? AND _type = ?",
+                  [op.id, op.modelName]
+                );
+                if (existing.length > 0) {
+                  const existingData = JSON.parse(existing[0]._data);
+                  const mergedData = { ...existingData, ...op.data };
+                  const violation = this._engine.checkUniqueConstraints(
+                    op.modelName,
+                    op.id,
+                    mergedData
+                  );
+                  if (violation) {
+                    pushFailure(i, {
+                      id: op.id,
+                      error: violation,
+                      status: 409,
+                      code: "UNIQUE_VIOLATION"
+                    });
+                    continue;
+                  }
+                }
+              }
+              const found = this._engine.patchRecordRaw(
+                op.modelName,
+                op.id,
+                op.data,
+                op.stringSets
+              );
+              if (!found) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+              } else {
+                if (op.data) fieldsToTrack.push({ modelName: op.modelName, data: op.data });
+                const patchResult = {
+                  success: true,
+                  id: op.id
+                };
+                const patchApplied = mergeAppliedFields(
+                  collectAppliedStamps(op.data, op.autoStamps, false),
+                  collectAppliedValues(op.data, batchAppliedNames.get(i))
+                );
+                if (patchApplied) patchResult.appliedFields = patchApplied;
+                results.push(patchResult);
+              }
+            } else if (op.op === "delete") {
+              this._engine.execSqlSync(
+                "DELETE FROM records WHERE _id = ? AND _type = ?",
+                [op.id, op.modelName]
+              );
+              this._engine.execSqlSync(
+                "DELETE FROM stringset_index WHERE _record_id = ? AND _type = ?",
+                [op.id, op.modelName]
+              );
+              results.push({ success: true, id: op.id });
+            } else if (op.op === "increment") {
+              const newValues = this._engine.incrementFieldsRaw(
+                op.modelName,
+                op.id,
+                op.fields
+              );
+              if (!newValues) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+              } else {
+                results.push({ success: true, id: op.id, values: newValues });
+              }
+            } else if (op.op === "addToSet") {
+              if (!this._engine.recordExists(op.modelName, op.id)) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+                continue;
+              }
+              this._engine.addToStringSetsRaw(
+                op.modelName,
+                op.id,
+                op.stringSets
+              );
+              results.push({ success: true, id: op.id });
+            } else if (op.op === "removeFromSet") {
+              if (!this._engine.recordExists(op.modelName, op.id)) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+                continue;
+              }
+              this._engine.removeFromStringSetsRaw(
+                op.modelName,
+                op.id,
+                op.stringSets
+              );
               results.push({ success: true, id: op.id });
             }
-          } else if (op.op === "delete") {
-            this._engine.execSqlSync(
-              "DELETE FROM records WHERE _id = ? AND _type = ?",
-              [op.id, op.modelName]
-            );
-            this._engine.execSqlSync(
-              "DELETE FROM stringset_index WHERE _record_id = ? AND _type = ?",
-              [op.id, op.modelName]
-            );
-            results.push({ success: true, id: op.id });
-          } else if (op.op === "increment") {
-            const newValues = this._engine.incrementFieldsRaw(
-              op.modelName,
-              op.id,
-              op.fields
-            );
-            if (!newValues) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-            } else {
-              results.push({ success: true, id: op.id, values: newValues });
-            }
-          } else if (op.op === "addToSet") {
-            if (!this._engine.recordExists(op.modelName, op.id)) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-              continue;
-            }
-            this._engine.addToStringSetsRaw(
-              op.modelName,
-              op.id,
-              op.stringSets
-            );
-            results.push({ success: true, id: op.id });
-          } else if (op.op === "removeFromSet") {
-            if (!this._engine.recordExists(op.modelName, op.id)) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-              continue;
-            }
-            this._engine.removeFromStringSetsRaw(
-              op.modelName,
-              op.id,
-              op.stringSets
-            );
-            results.push({ success: true, id: op.id });
           }
+        });
+      } catch (err) {
+        if (err instanceof AtomicBatchAbort) {
+          const failed = results[err.failedIndex];
+          const failedOp = operations[err.failedIndex];
+          console.warn(
+            `[js-bao batch] atomic rollback: operation ${err.failedIndex} (${failedOp?.op}) failed \u2014 ${failed?.error ?? "unknown error"}`
+          );
+          const errorBody = {
+            error: `Operation ${err.failedIndex} (${failedOp?.op}) failed: ${failed?.error ?? "unknown error"}`,
+            failedIndex: err.failedIndex,
+            op: failedOp?.op,
+            code: failed?.code
+          };
+          return Response.json(errorBody, { status: failed?.status ?? 409 });
         }
-      });
+        throw err;
+      }
       for (const entry of fieldsToTrack) {
         this._engine.trackModelFields(entry.modelName, entry.data);
       }
@@ -3454,6 +3687,18 @@ function createDatabaseDO(config = {}) {
         }
         return facetResult;
       }
+      if (aggOptions.groupBy.length === 0) {
+        const row = results[0];
+        const flat = {};
+        for (const op of aggOptions.operations) {
+          if (op.type === "count") {
+            flat.count = row.count;
+          } else {
+            flat[`${op.type}_${op.field}`] = row[`${op.type}_${op.field}`];
+          }
+        }
+        return flat;
+      }
       const nestedResult = {};
       const aliasLookup = /* @__PURE__ */ new Map();
       for (const entry of aliasMap) {
@@ -3781,16 +4026,7 @@ function createDatabaseDO(config = {}) {
     }
     /** @internal */
     _parseRow(row) {
-      const { _id, _type, _data, ...rest } = row;
-      let parsed = {};
-      if (_data) {
-        try {
-          parsed = JSON.parse(_data);
-        } catch (e) {
-          console.warn("Failed to parse _data:", e);
-        }
-      }
-      return { id: _id, type: _type, ...parsed, ...rest };
+      return parseRecordRow(row);
     }
     // ─── Include (Related Data Loading) ──────────────────────────────
     /** @internal — Validate an IncludeSpec, returning an error message or null */
@@ -3920,8 +4156,9 @@ function createDatabaseDO(config = {}) {
         spec.filter,
         { projection: spec.projection }
       );
+      const relatedProjected = spec.projection ? related.map((r) => this._applyProjection(r, spec.projection)) : related;
       const lookupMap = /* @__PURE__ */ new Map();
-      for (const r of related) {
+      for (const r of relatedProjected) {
         lookupMap.set(r.id, r);
       }
       for (const rec of records) {
@@ -3954,8 +4191,9 @@ function createDatabaseDO(config = {}) {
         spec.filter,
         { projection: spec.projection }
       );
+      const targetsProjected = spec.projection ? targets.map((t) => this._applyProjection(t, spec.projection)) : targets;
       const targetLookup = /* @__PURE__ */ new Map();
-      for (const t of targets) {
+      for (const t of targetsProjected) {
         targetLookup.set(t.id, t);
       }
       for (const rec of records) {
@@ -4099,6 +4337,14 @@ function createDatabaseDO(config = {}) {
       return allResults;
     }
     /** @internal — Apply projection to a single record */
+    // Apply a projection to a single record. Assumes the projection has
+    // already been validated upstream (JsonQueryTranslator.validateProjection /
+    // buildSelectClause reject mixed inclusion+exclusion): `isInclusion` treats
+    // "any value === 1" as inclusion mode, so an unvalidated mixed projection
+    // would silently ignore the excludes. `id` and `type` are system-identity
+    // fields and are always kept in BOTH modes (a record without its `id` is
+    // unusable downstream). `_meta` is NOT forced — an explicit `{ _meta: 0 }`
+    // is honored.
     _applyProjection(record, projection) {
       const fields = Object.entries(projection);
       if (fields.length === 0) return record;
@@ -4117,7 +4363,7 @@ function createDatabaseDO(config = {}) {
       } else {
         const result = { ...record };
         for (const [f, v] of fields) {
-          if (v === 0) delete result[f];
+          if (v === 0 && f !== "id" && f !== "type") delete result[f];
         }
         return result;
       }
@@ -4395,6 +4641,7 @@ var import_smol_toml = require("smol-toml");
 // src/models/schema.ts
 init_BaseModel();
 init_ModelRegistry();
+init_uniqueIndex();
 function defineModelSchema(input) {
   const { name, fields } = input;
   const options = {
@@ -4437,7 +4684,7 @@ function resolveUniqueConstraints(modelName, fields, customConstraints) {
   for (const [fieldName, options] of fields.entries()) {
     if (options.unique) {
       resolved.push({
-        name: `${modelName}_${fieldName}_unique`,
+        name: fieldUniqueConstraintName(modelName, fieldName),
         fields: [fieldName]
       });
     }