@korajs/store 0.6.0 → 1.0.0-beta.1

package/dist/internal.cjs

@@ -54,10 +54,28 @@ __export(internal_exports, {
 module.exports = __toCommonJS(internal_exports);
 
 // src/serialization/serializer.ts
-var import_core = require("@korajs/core");
+var import_core2 = require("@korajs/core");
 
 // src/serialization/richtext-serializer.ts
 var Y = __toESM(require("yjs"), 1);
+
+// src/serialization/op-data-encoding.ts
+var import_core = require("@korajs/core");
+var decodeRichtextOpDataValue = import_core.decodeBytesFromOpData;
+function encodeRichtextFieldsForOpData(data, fields) {
+  const result = { ...data };
+  for (const [key, value] of Object.entries(data)) {
+    if (fields[key]?.kind !== "richtext") {
+      continue;
+    }
+    if (typeof value === "string" || value instanceof Uint8Array || value instanceof ArrayBuffer) {
+      result[key] = (0, import_core.encodeBytesForOpData)(value);
+    }
+  }
+  return result;
+}
+
+// src/serialization/richtext-serializer.ts
 var TEXT_KEY = "content";
 function encodeRichtext(value) {
   if (value === null || value === void 0) {
@@ -74,6 +92,10 @@ function encodeRichtext(value) {
   if (value instanceof ArrayBuffer) {
     return new Uint8Array(value);
   }
+  if ((0, import_core.isKoraBytesValue)(value) || (0, import_core.isLegacyNumericByteObject)(value)) {
+    const decoded = decodeRichtextOpDataValue(value);
+    return decoded instanceof Uint8Array ? decoded : null;
+  }
   throw new Error("Richtext value must be a string, Uint8Array, ArrayBuffer, null, or undefined.");
 }
 function decodeRichtext(value) {
@@ -156,7 +178,7 @@ function serializeOperation(op) {
     record_id: op.recordId,
     data: dataPayload ? JSON.stringify(dataPayload) : null,
     previous_data: op.previousData ? JSON.stringify(op.previousData) : null,
-    timestamp: import_core.HybridLogicalClock.serialize(op.timestamp),
+    timestamp: import_core2.HybridLogicalClock.serialize(op.timestamp),
     sequence_number: op.sequenceNumber,
     causal_deps: JSON.stringify(op.causalDeps),
     schema_version: op.schemaVersion
@@ -190,7 +212,7 @@ function deserializeOperation(row) {
     recordId: row.record_id,
     data,
     previousData: row.previous_data ? JSON.parse(row.previous_data) : null,
-    timestamp: import_core.HybridLogicalClock.deserialize(row.timestamp),
+    timestamp: import_core2.HybridLogicalClock.deserialize(row.timestamp),
     sequenceNumber: row.sequence_number,
     causalDeps: JSON.parse(row.causal_deps),
     schemaVersion: row.schema_version,
@@ -211,6 +233,9 @@ function serializeValue(value, descriptor) {
     case "boolean":
       return value ? 1 : 0;
     case "array":
+    case "object":
+    case "json":
+    case "blob":
       return JSON.stringify(value);
     case "richtext":
       return encodeRichtext(value);
@@ -227,6 +252,13 @@ function deserializeValue(value, descriptor) {
         return JSON.parse(value);
       }
       return value;
+    case "object":
+    case "json":
+    case "blob":
+      if (typeof value === "string") {
+        return JSON.parse(value);
+      }
+      return value;
     case "richtext":
       return decodeRichtext(value);
     default:
@@ -235,14 +267,14 @@ function deserializeValue(value, descriptor) {
 }
 
 // src/errors.ts
-var import_core2 = require("@korajs/core");
-var QueryError = class extends import_core2.KoraError {
+var import_core3 = require("@korajs/core");
+var QueryError = class extends import_core3.KoraError {
   constructor(message, context) {
     super(message, "QUERY_ERROR", context);
     this.name = "QueryError";
   }
 };
-var RecordNotFoundError = class extends import_core2.KoraError {
+var RecordNotFoundError = class extends import_core3.KoraError {
   constructor(collection, recordId) {
     super(`Record "${recordId}" not found in collection "${collection}"`, "RECORD_NOT_FOUND", {
       collection,
@@ -253,20 +285,20 @@ var RecordNotFoundError = class extends import_core2.KoraError {
 };
 
 // src/lww/row-version.ts
-var import_core3 = require("@korajs/core");
+var import_core4 = require("@korajs/core");
 var EMPTY_ROW_VERSION = "";
 function serializeRowVersion(timestamp) {
-  return import_core3.HybridLogicalClock.serialize(timestamp);
+  return import_core4.HybridLogicalClock.serialize(timestamp);
 }
 function rowVersionFromRecord(row) {
   const version = row._version;
   if (typeof version === "string" && version.length > 0) {
-    return import_core3.HybridLogicalClock.deserialize(version);
+    return import_core4.HybridLogicalClock.deserialize(version);
   }
   return { wallTime: row._updated_at, logical: 0, nodeId: "" };
 }
 function isIncomingNewerThanRow(incoming, row) {
-  return import_core3.HybridLogicalClock.compare(incoming, rowVersionFromRecord(row)) > 0;
+  return import_core4.HybridLogicalClock.compare(incoming, rowVersionFromRecord(row)) > 0;
 }
 function lwwVersionWhereClause(remoteVersion) {
   return {
@@ -447,7 +479,39 @@ function validateFieldName(fieldName, fields) {
 }
 
 // src/mutations/execute-insert.ts
-var import_core4 = require("@korajs/core");
+var import_core5 = require("@korajs/core");
+
+// src/lww/field-versions.ts
+function parseFieldVersions(raw) {
+  if (typeof raw !== "string" || raw.length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "string") {
+        result[key] = value;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function serializeFieldVersions(versions) {
+  return JSON.stringify(versions);
+}
+function fieldVersionsForFields(fieldNames, version) {
+  const versions = {};
+  for (const field of fieldNames) {
+    versions[field] = version;
+  }
+  return versions;
+}
 
 // src/store/sequence-allocator.ts
 async function allocateNextSequenceInTransaction(tx, nodeId) {
@@ -482,25 +546,33 @@ function resolveCausalDeps(ctx) {
 
 // src/mutations/execute-insert.ts
 async function executeInsert(ctx, data) {
-  const validated = (0, import_core4.validateRecord)(ctx.collection, ctx.definition, data, "insert");
-  const recordId = (0, import_core4.generateUUIDv7)();
+  const validated = (0, import_core5.validateRecord)(ctx.collection, ctx.definition, data, "insert");
+  const recordId = (0, import_core5.generateUUIDv7)();
   for (const [fieldName, descriptor] of Object.entries(ctx.definition.fields)) {
     if (descriptor.auto && descriptor.kind === "timestamp") {
       validated[fieldName] = Date.now();
     }
   }
+  const writeData = await (0, import_core5.transformSecretFieldsForWrite)(
+    validated,
+    ctx.definition,
+    ctx.secretKeyProvider
+  );
   const causalDeps = resolveCausalDeps(ctx);
   let operation;
   let record;
   await ctx.adapter.transaction(async (tx) => {
     const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-    operation = await (0, import_core4.createOperation)(
+    operation = await (0, import_core5.createOperation)(
       {
         nodeId: ctx.nodeId,
         type: "insert",
         collection: ctx.collection,
         recordId,
-        data: { ...validated },
+        // Binary richtext values are tagged as canonical JSON BEFORE the
+        // operation is content-hashed, so the hash input, persisted JSON,
+        // and wire payload are the identical value.
+        data: encodeRichtextFieldsForOpData(writeData, ctx.definition.fields),
         previousData: null,
         sequenceNumber,
         causalDeps,
@@ -509,14 +581,19 @@ async function executeInsert(ctx, data) {
       ctx.clock
     );
     ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
-    const serializedData = serializeRecord(validated, ctx.definition.fields);
+    const serializedData = serializeRecord(writeData, ctx.definition.fields);
     const version = serializeRowVersion(operation.timestamp);
     record = {
       id: recordId,
       ...serializedData,
       _created_at: operation.timestamp.wallTime,
       _updated_at: operation.timestamp.wallTime,
-      _version: version
+      _version: version,
+      // Stamp every inserted field with this operation's version so later
+      // per-field LWW compares against a real writer, not the fallback.
+      _field_versions: serializeFieldVersions(
+        fieldVersionsForFields(Object.keys(serializedData), version)
+      )
     };
     const builtInsert = buildInsertQuery(ctx.collection, record);
     const opInsert = buildInsertQuery(
@@ -529,18 +606,18 @@ async function executeInsert(ctx, data) {
   ctx.onMutation(ctx.collection, operation);
   return {
     id: recordId,
-    ...validated,
+    ...writeData,
     createdAt: operation.timestamp.wallTime,
     updatedAt: operation.timestamp.wallTime
   };
 }
 
 // src/mutations/execute-update.ts
-var import_core6 = require("@korajs/core");
+var import_core7 = require("@korajs/core");
 
 // src/state-machine/state-validator.ts
-var import_core5 = require("@korajs/core");
-var InvalidStateTransitionError = class extends import_core5.KoraError {
+var import_core6 = require("@korajs/core");
+var InvalidStateTransitionError = class extends import_core6.KoraError {
   constructor(collection, recordId, field, fromState, toState, allowedStates) {
     super(
       `Invalid state transition in collection "${collection}": cannot transition field "${field}" from "${fromState}" to "${toState}". Allowed transitions from "${fromState}": ${allowedStates.length > 0 ? allowedStates.join(", ") : "(none -- terminal state)"}`,
@@ -574,7 +651,7 @@ function validateStateTransition(collectionName, recordId, stateMachine, current
     collection: collectionName,
     transitions: stateMachine.transitions
   };
-  const transitionResult = (0, import_core5.validateTransition)(constraint, currentState, newState);
+  const transitionResult = (0, import_core6.validateTransition)(constraint, currentState, newState);
   if (transitionResult.valid) {
     return { valid: true, allowedStates: transitionResult.allowedTargets };
   }
@@ -630,7 +707,7 @@ async function executeUpdate(ctx, id, data) {
   if (!currentRow) {
     throw new RecordNotFoundError(ctx.collection, id);
   }
-  let validated = (0, import_core6.validateRecord)(ctx.collection, ctx.definition, data, "update");
+  let validated = (0, import_core7.validateRecord)(ctx.collection, ctx.definition, data, "update");
   const currentRecord = deserializeRecord(currentRow, ctx.definition.fields);
   validated = validateUpdateStateMachine(
     ctx.collection,
@@ -648,26 +725,34 @@ async function executeUpdate(ctx, id, data) {
   for (const key of Object.keys(validated)) {
     const value = validated[key];
     previousData[key] = currentRecord[key];
-    if ((0, import_core6.isAtomicOp)(value)) {
-      resolvedData[key] = (0, import_core6.resolveAtomicOp)(currentRecord[key], value);
-      atomicOps[key] = (0, import_core6.toAtomicOp)(value);
+    if ((0, import_core7.isAtomicOp)(value)) {
+      resolvedData[key] = (0, import_core7.resolveAtomicOp)(currentRecord[key], value);
+      atomicOps[key] = (0, import_core7.toAtomicOp)(value);
     } else {
       resolvedData[key] = value;
     }
   }
+  const writeData = await (0, import_core7.transformSecretFieldsForWrite)(
+    resolvedData,
+    ctx.definition,
+    ctx.secretKeyProvider
+  );
   const hasAtomicOps = Object.keys(atomicOps).length > 0;
   const causalDeps = resolveCausalDeps(ctx);
   let operation;
   await ctx.adapter.transaction(async (tx) => {
     const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-    operation = await (0, import_core6.createOperation)(
+    operation = await (0, import_core7.createOperation)(
       {
         nodeId: ctx.nodeId,
         type: "update",
         collection: ctx.collection,
         recordId: id,
-        data: { ...resolvedData },
-        previousData,
+        // Binary richtext values (new and previous) are tagged as canonical
+        // JSON BEFORE the operation is content-hashed, so the hash input,
+        // persisted JSON, and wire payload are the identical value.
+        data: encodeRichtextFieldsForOpData(writeData, ctx.definition.fields),
+        previousData: encodeRichtextFieldsForOpData(previousData, ctx.definition.fields),
         sequenceNumber,
         causalDeps,
         schemaVersion: ctx.schema.version,
@@ -676,12 +761,17 @@ async function executeUpdate(ctx, id, data) {
       ctx.clock
     );
     ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
-    const serializedChanges = serializeRecord(resolvedData, ctx.definition.fields);
+    const serializedChanges = serializeRecord(writeData, ctx.definition.fields);
     const version = serializeRowVersion(operation.timestamp);
+    const mergedFieldVersions = parseFieldVersions(currentRow._field_versions);
+    for (const changedField of Object.keys(serializedChanges)) {
+      mergedFieldVersions[changedField] = version;
+    }
     const updateQuery = buildUpdateQuery(ctx.collection, id, {
       ...serializedChanges,
       _updated_at: operation.timestamp.wallTime,
-      _version: version
+      _version: version,
+      _field_versions: serializeFieldVersions(mergedFieldVersions)
     });
     const opInsert = buildInsertQuery(
       `_kora_ops_${ctx.collection}`,
@@ -703,7 +793,7 @@ async function executeUpdate(ctx, id, data) {
 }
 
 // src/mutations/execute-delete.ts
-var import_core7 = require("@korajs/core");
+var import_core8 = require("@korajs/core");
 async function executeDelete(ctx, id, options) {
   const currentRows = await ctx.adapter.query(
     `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
@@ -718,7 +808,7 @@ async function executeDelete(ctx, id, options) {
   await ctx.adapter.transaction(async (tx) => {
     if (!operation) {
       const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-      operation = await (0, import_core7.createOperation)(
+      operation = await (0, import_core8.createOperation)(
         {
           nodeId: ctx.nodeId,
           type: "delete",