@korajs/store 0.3.2 → 0.5.0

package/dist/internal.cjs

@@ -0,0 +1,789 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  buildCountQuery: () => buildCountQuery,
+  buildInsertQuery: () => buildInsertQuery,
+  buildLwwSoftDeleteQuery: () => buildLwwSoftDeleteQuery,
+  buildLwwUpdateQuery: () => buildLwwUpdateQuery,
+  buildSelectQuery: () => buildSelectQuery,
+  buildSoftDeleteQuery: () => buildSoftDeleteQuery,
+  buildUpdateQuery: () => buildUpdateQuery,
+  buildWhereClause: () => buildWhereClause,
+  deserializeOperation: () => deserializeOperation,
+  deserializeOperationWithCollection: () => deserializeOperationWithCollection,
+  deserializeRecord: () => deserializeRecord,
+  executeDelete: () => executeDelete,
+  executeInsert: () => executeInsert,
+  executeUpdate: () => executeUpdate,
+  isIncomingNewerThanRow: () => isIncomingNewerThanRow,
+  resolveCausalDeps: () => resolveCausalDeps,
+  rowVersionFromRecord: () => rowVersionFromRecord,
+  serializeOperation: () => serializeOperation,
+  serializeRecord: () => serializeRecord,
+  serializeRowVersion: () => serializeRowVersion
+});
+module.exports = __toCommonJS(internal_exports);
+
+// src/serialization/serializer.ts
+var import_core = require("@korajs/core");
+
+// src/serialization/richtext-serializer.ts
+var Y = __toESM(require("yjs"), 1);
+var TEXT_KEY = "content";
+function encodeRichtext(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    const doc = new Y.Doc();
+    doc.getText(TEXT_KEY).insert(0, value);
+    return Y.encodeStateAsUpdate(doc);
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  throw new Error("Richtext value must be a string, Uint8Array, ArrayBuffer, null, or undefined.");
+}
+function decodeRichtext(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return new Uint8Array(value);
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  throw new Error(
+    "Richtext storage value must be Uint8Array, ArrayBuffer, Buffer, null, or undefined."
+  );
+}
+
+// src/serialization/serializer.ts
+function serializeRecord(data, fields) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    const descriptor = fields[key];
+    if (!descriptor) {
+      result[key] = value;
+      continue;
+    }
+    result[key] = serializeValue(value, descriptor);
+  }
+  return result;
+}
+function deserializeRecord(row, fields) {
+  const result = {
+    id: row.id,
+    createdAt: row._created_at,
+    updatedAt: row._updated_at
+  };
+  for (const [key, descriptor] of Object.entries(fields)) {
+    const rawValue = row[key];
+    if (rawValue === void 0 || rawValue === null) {
+      result[key] = rawValue ?? null;
+      continue;
+    }
+    result[key] = deserializeValue(rawValue, descriptor);
+  }
+  return result;
+}
+var ATOMIC_OPS_KEY = "__kora_atomic_ops__";
+var TX_ID_KEY = "__kora_tx_id__";
+var MUTATION_NAME_KEY = "__kora_mutation__";
+function serializeOperation(op) {
+  const hasMetadata = op.transactionId !== void 0 || op.mutationName !== void 0;
+  let dataPayload = null;
+  if (op.data) {
+    dataPayload = { ...op.data };
+    if (op.atomicOps !== void 0 && Object.keys(op.atomicOps).length > 0) {
+      dataPayload[ATOMIC_OPS_KEY] = op.atomicOps;
+    }
+    if (op.transactionId !== void 0) {
+      dataPayload[TX_ID_KEY] = op.transactionId;
+    }
+    if (op.mutationName !== void 0) {
+      dataPayload[MUTATION_NAME_KEY] = op.mutationName;
+    }
+  } else if (hasMetadata) {
+    dataPayload = {};
+    if (op.transactionId !== void 0) {
+      dataPayload[TX_ID_KEY] = op.transactionId;
+    }
+    if (op.mutationName !== void 0) {
+      dataPayload[MUTATION_NAME_KEY] = op.mutationName;
+    }
+  }
+  return {
+    id: op.id,
+    node_id: op.nodeId,
+    type: op.type,
+    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),
+    sequence_number: op.sequenceNumber,
+    causal_deps: JSON.stringify(op.causalDeps),
+    schema_version: op.schemaVersion
+  };
+}
+function deserializeOperation(row) {
+  let data = null;
+  let atomicOps;
+  let transactionId;
+  let mutationName;
+  if (row.data) {
+    const parsed = JSON.parse(row.data);
+    if (ATOMIC_OPS_KEY in parsed) {
+      atomicOps = parsed[ATOMIC_OPS_KEY];
+    }
+    if (TX_ID_KEY in parsed) {
+      transactionId = parsed[TX_ID_KEY];
+    }
+    if (MUTATION_NAME_KEY in parsed) {
+      mutationName = parsed[MUTATION_NAME_KEY];
+    }
+    const { [ATOMIC_OPS_KEY]: _a, [TX_ID_KEY]: _t, [MUTATION_NAME_KEY]: _m, ...rest } = parsed;
+    data = Object.keys(rest).length > 0 ? rest : null;
+  }
+  return {
+    id: row.id,
+    nodeId: row.node_id,
+    type: row.type,
+    collection: "",
+    // Collection name is derived from the table name by the caller
+    recordId: row.record_id,
+    data,
+    previousData: row.previous_data ? JSON.parse(row.previous_data) : null,
+    timestamp: import_core.HybridLogicalClock.deserialize(row.timestamp),
+    sequenceNumber: row.sequence_number,
+    causalDeps: JSON.parse(row.causal_deps),
+    schemaVersion: row.schema_version,
+    ...atomicOps !== void 0 ? { atomicOps } : {},
+    ...transactionId !== void 0 ? { transactionId } : {},
+    ...mutationName !== void 0 ? { mutationName } : {}
+  };
+}
+function deserializeOperationWithCollection(row, collection) {
+  const op = deserializeOperation(row);
+  return { ...op, collection };
+}
+function serializeValue(value, descriptor) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  switch (descriptor.kind) {
+    case "boolean":
+      return value ? 1 : 0;
+    case "array":
+      return JSON.stringify(value);
+    case "richtext":
+      return encodeRichtext(value);
+    default:
+      return value;
+  }
+}
+function deserializeValue(value, descriptor) {
+  switch (descriptor.kind) {
+    case "boolean":
+      return value === 1 || value === true;
+    case "array":
+      if (typeof value === "string") {
+        return JSON.parse(value);
+      }
+      return value;
+    case "richtext":
+      return decodeRichtext(value);
+    default:
+      return value;
+  }
+}
+
+// src/errors.ts
+var import_core2 = require("@korajs/core");
+var QueryError = class extends import_core2.KoraError {
+  constructor(message, context) {
+    super(message, "QUERY_ERROR", context);
+    this.name = "QueryError";
+  }
+};
+var RecordNotFoundError = class extends import_core2.KoraError {
+  constructor(collection, recordId) {
+    super(`Record "${recordId}" not found in collection "${collection}"`, "RECORD_NOT_FOUND", {
+      collection,
+      recordId
+    });
+    this.name = "RecordNotFoundError";
+  }
+};
+
+// src/lww/row-version.ts
+var import_core3 = require("@korajs/core");
+var EMPTY_ROW_VERSION = "";
+function serializeRowVersion(timestamp) {
+  return import_core3.HybridLogicalClock.serialize(timestamp);
+}
+function rowVersionFromRecord(row) {
+  const version = row._version;
+  if (typeof version === "string" && version.length > 0) {
+    return import_core3.HybridLogicalClock.deserialize(version);
+  }
+  return { wallTime: row._updated_at, logical: 0, nodeId: "" };
+}
+function isIncomingNewerThanRow(incoming, row) {
+  return import_core3.HybridLogicalClock.compare(incoming, rowVersionFromRecord(row)) > 0;
+}
+function lwwVersionWhereClause(remoteVersion) {
+  return {
+    sql: "(_version = ? OR _version < ?)",
+    params: [EMPTY_ROW_VERSION, remoteVersion]
+  };
+}
+
+// src/query/sql-builder.ts
+function buildSelectQuery(descriptor, fields) {
+  const params = [];
+  const parts = [`SELECT * FROM ${descriptor.collection}`];
+  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
+  const deletedFilter = "_deleted = 0";
+  if (whereClause) {
+    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
+  } else {
+    parts.push(`WHERE ${deletedFilter}`);
+  }
+  if (descriptor.orderBy.length > 0) {
+    const orderParts = descriptor.orderBy.map((o) => {
+      validateFieldName(o.field, fields);
+      return `${o.field} ${o.direction.toUpperCase()}`;
+    });
+    parts.push(`ORDER BY ${orderParts.join(", ")}`);
+  }
+  if (descriptor.limit !== void 0) {
+    parts.push(`LIMIT ${descriptor.limit}`);
+  }
+  if (descriptor.offset !== void 0) {
+    parts.push(`OFFSET ${descriptor.offset}`);
+  }
+  return { sql: parts.join(" "), params };
+}
+function buildCountQuery(descriptor, fields) {
+  const params = [];
+  const parts = [`SELECT COUNT(*) as count FROM ${descriptor.collection}`];
+  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
+  const deletedFilter = "_deleted = 0";
+  if (whereClause) {
+    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
+  } else {
+    parts.push(`WHERE ${deletedFilter}`);
+  }
+  return { sql: parts.join(" "), params };
+}
+function buildInsertQuery(collection, record) {
+  const columns = Object.keys(record);
+  const placeholders = columns.map(() => "?");
+  const params = Object.values(record);
+  const sql = `INSERT INTO ${collection} (${columns.join(", ")}) VALUES (${placeholders.join(", ")})`;
+  return { sql, params };
+}
+function buildUpdateQuery(collection, id, changes) {
+  const setClauses = Object.keys(changes).map((col) => `${col} = ?`);
+  const params = [...Object.values(changes), id];
+  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ?`;
+  return { sql, params };
+}
+function buildSoftDeleteQuery(collection, id, updatedAt, version) {
+  if (version !== void 0) {
+    return {
+      sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ?`,
+      params: [updatedAt, version, id]
+    };
+  }
+  return {
+    sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ? WHERE id = ?`,
+    params: [updatedAt, id]
+  };
+}
+function buildLwwUpdateQuery(collection, id, changes, remoteVersion) {
+  const setClauses = Object.keys(changes).map((col) => `${col} = ?`);
+  const lww = lwwVersionWhereClause(remoteVersion);
+  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ? AND ${lww.sql}`;
+  const params = [...Object.values(changes), id, ...lww.params];
+  return { sql, params };
+}
+function buildLwwSoftDeleteQuery(collection, id, updatedAt, version) {
+  const lww = lwwVersionWhereClause(version);
+  return {
+    sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ? AND ${lww.sql}`,
+    params: [updatedAt, version, id, ...lww.params]
+  };
+}
+function buildWhereClause(where, fields) {
+  const params = [];
+  const result = buildWhereClauseParts(where, fields, params);
+  if (!result) return null;
+  return { sql: result, params };
+}
+var VALID_OPERATORS = /* @__PURE__ */ new Set(["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in"]);
+function buildWhereClauseParts(where, fields, params) {
+  const conditions = [];
+  for (const [fieldName, value] of Object.entries(where)) {
+    validateFieldName(fieldName, fields);
+    const descriptor = fields[fieldName];
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const ops = value;
+      for (const [op, opValue] of Object.entries(ops)) {
+        if (!VALID_OPERATORS.has(op)) {
+          throw new QueryError(`Unknown operator "${op}" on field "${fieldName}"`, {
+            field: fieldName,
+            operator: op,
+            validOperators: [...VALID_OPERATORS]
+          });
+        }
+        conditions.push(buildOperatorCondition(fieldName, op, opValue, descriptor, params));
+      }
+    } else {
+      conditions.push(buildOperatorCondition(fieldName, "$eq", value, descriptor, params));
+    }
+  }
+  if (conditions.length === 0) return null;
+  return conditions.join(" AND ");
+}
+function buildOperatorCondition(fieldName, operator, value, descriptor, params) {
+  const sqlValue = descriptor?.kind === "boolean" && typeof value === "boolean" ? value ? 1 : 0 : value;
+  switch (operator) {
+    case "$eq":
+      if (sqlValue === null) {
+        return `${fieldName} IS NULL`;
+      }
+      params.push(sqlValue);
+      return `${fieldName} = ?`;
+    case "$ne":
+      if (sqlValue === null) {
+        return `${fieldName} IS NOT NULL`;
+      }
+      params.push(sqlValue);
+      return `${fieldName} != ?`;
+    case "$gt":
+      params.push(sqlValue);
+      return `${fieldName} > ?`;
+    case "$gte":
+      params.push(sqlValue);
+      return `${fieldName} >= ?`;
+    case "$lt":
+      params.push(sqlValue);
+      return `${fieldName} < ?`;
+    case "$lte":
+      params.push(sqlValue);
+      return `${fieldName} <= ?`;
+    case "$in": {
+      if (!Array.isArray(sqlValue)) {
+        throw new QueryError(`$in operator requires an array value for field "${fieldName}"`, {
+          field: fieldName,
+          received: typeof sqlValue
+        });
+      }
+      const placeholders = sqlValue.map(() => "?");
+      for (const item of sqlValue) {
+        params.push(
+          descriptor?.kind === "boolean" && typeof item === "boolean" ? item ? 1 : 0 : item
+        );
+      }
+      return `${fieldName} IN (${placeholders.join(", ")})`;
+    }
+    default:
+      throw new QueryError(`Unknown operator "${operator}"`, { operator });
+  }
+}
+function validateFieldName(fieldName, fields) {
+  const allowedFields = /* @__PURE__ */ new Set([
+    ...Object.keys(fields),
+    "id",
+    "createdAt",
+    "updatedAt",
+    "_created_at",
+    "_updated_at"
+  ]);
+  if (!allowedFields.has(fieldName)) {
+    throw new QueryError(
+      `Unknown field "${fieldName}" in query. Available fields: ${[...allowedFields].join(", ")}`,
+      { field: fieldName }
+    );
+  }
+}
+
+// src/mutations/execute-insert.ts
+var import_core4 = require("@korajs/core");
+
+// src/store/sequence-allocator.ts
+async function allocateNextSequenceInTransaction(tx, nodeId) {
+  const rows = await tx.query(
+    `INSERT INTO _kora_version_vector (node_id, sequence_number) VALUES (?, 1)
+     ON CONFLICT(node_id) DO UPDATE SET sequence_number = sequence_number + 1
+     RETURNING sequence_number`,
+    [nodeId]
+  );
+  const seq = rows[0]?.sequence_number;
+  if (seq === void 0) {
+    throw new Error(`Failed to allocate sequence number for node "${nodeId}" in transaction`);
+  }
+  return seq;
+}
+
+// src/mutations/resolve-causal-deps.ts
+function resolveCausalDeps(ctx) {
+  const merged = [];
+  for (const id of ctx.extraCausalDeps ?? []) {
+    if (!merged.includes(id)) {
+      merged.push(id);
+    }
+  }
+  for (const id of ctx.causalTracker?.nextCausalDeps(ctx.collection, ctx.inTransaction) ?? []) {
+    if (!merged.includes(id)) {
+      merged.push(id);
+    }
+  }
+  return merged;
+}
+
+// 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)();
+  for (const [fieldName, descriptor] of Object.entries(ctx.definition.fields)) {
+    if (descriptor.auto && descriptor.kind === "timestamp") {
+      validated[fieldName] = Date.now();
+    }
+  }
+  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)(
+      {
+        nodeId: ctx.nodeId,
+        type: "insert",
+        collection: ctx.collection,
+        recordId,
+        data: { ...validated },
+        previousData: null,
+        sequenceNumber,
+        causalDeps,
+        schemaVersion: ctx.schema.version
+      },
+      ctx.clock
+    );
+    ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
+    const serializedData = serializeRecord(validated, ctx.definition.fields);
+    const version = serializeRowVersion(operation.timestamp);
+    record = {
+      id: recordId,
+      ...serializedData,
+      _created_at: operation.timestamp.wallTime,
+      _updated_at: operation.timestamp.wallTime,
+      _version: version
+    };
+    const builtInsert = buildInsertQuery(ctx.collection, record);
+    const opInsert = buildInsertQuery(
+      `_kora_ops_${ctx.collection}`,
+      serializeOperation(operation)
+    );
+    await tx.execute(builtInsert.sql, builtInsert.params);
+    await tx.execute(opInsert.sql, opInsert.params);
+  });
+  ctx.onMutation(ctx.collection, operation);
+  return {
+    id: recordId,
+    ...validated,
+    createdAt: operation.timestamp.wallTime,
+    updatedAt: operation.timestamp.wallTime
+  };
+}
+
+// src/mutations/execute-update.ts
+var import_core6 = require("@korajs/core");
+
+// src/state-machine/state-validator.ts
+var import_core5 = require("@korajs/core");
+var InvalidStateTransitionError = class extends import_core5.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)"}`,
+      "INVALID_STATE_TRANSITION",
+      { collection, recordId, field, fromState, toState, allowedStates }
+    );
+    this.collection = collection;
+    this.recordId = recordId;
+    this.field = field;
+    this.fromState = fromState;
+    this.toState = toState;
+    this.allowedStates = allowedStates;
+    this.name = "InvalidStateTransitionError";
+  }
+  collection;
+  recordId;
+  field;
+  fromState;
+  toState;
+  allowedStates;
+};
+function validateStateTransition(collectionName, recordId, stateMachine, currentState, newState) {
+  if (currentState === null) {
+    return { valid: true, allowedStates: [] };
+  }
+  if (currentState === newState) {
+    return { valid: true, allowedStates: stateMachine.transitions[currentState] ?? [] };
+  }
+  const constraint = {
+    field: stateMachine.field,
+    collection: collectionName,
+    transitions: stateMachine.transitions
+  };
+  const transitionResult = (0, import_core5.validateTransition)(constraint, currentState, newState);
+  if (transitionResult.valid) {
+    return { valid: true, allowedStates: transitionResult.allowedTargets };
+  }
+  const allowedStates = transitionResult.allowedTargets;
+  if (stateMachine.onInvalidTransition === "reject") {
+    throw new InvalidStateTransitionError(
+      collectionName,
+      recordId,
+      stateMachine.field,
+      currentState,
+      newState,
+      allowedStates
+    );
+  }
+  return { valid: false, allowedStates };
+}
+function validateUpdateStateMachine(collectionName, recordId, collectionDef, currentRecord, updateData) {
+  const stateMachine = collectionDef.stateMachine;
+  if (stateMachine === void 0) {
+    return updateData;
+  }
+  const stateField = stateMachine.field;
+  if (!(stateField in updateData)) {
+    return updateData;
+  }
+  const currentState = currentRecord[stateField];
+  const newState = updateData[stateField];
+  if (typeof currentState !== "string" || typeof newState !== "string") {
+    return updateData;
+  }
+  const result = validateStateTransition(
+    collectionName,
+    recordId,
+    stateMachine,
+    currentState,
+    newState
+  );
+  if (result.valid) {
+    return updateData;
+  }
+  const filtered = { ...updateData };
+  delete filtered[stateField];
+  return filtered;
+}
+
+// src/mutations/execute-update.ts
+async function executeUpdate(ctx, id, data) {
+  const currentRows = await ctx.adapter.query(
+    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    [id]
+  );
+  const currentRow = currentRows[0];
+  if (!currentRow) {
+    throw new RecordNotFoundError(ctx.collection, id);
+  }
+  let validated = (0, import_core6.validateRecord)(ctx.collection, ctx.definition, data, "update");
+  const currentRecord = deserializeRecord(currentRow, ctx.definition.fields);
+  validated = validateUpdateStateMachine(
+    ctx.collection,
+    id,
+    ctx.definition,
+    currentRecord,
+    validated
+  );
+  if (Object.keys(validated).length === 0) {
+    return { ...currentRecord };
+  }
+  const previousData = {};
+  const resolvedData = {};
+  const atomicOps = {};
+  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);
+    } else {
+      resolvedData[key] = value;
+    }
+  }
+  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)(
+      {
+        nodeId: ctx.nodeId,
+        type: "update",
+        collection: ctx.collection,
+        recordId: id,
+        data: { ...resolvedData },
+        previousData,
+        sequenceNumber,
+        causalDeps,
+        schemaVersion: ctx.schema.version,
+        ...hasAtomicOps ? { atomicOps } : {}
+      },
+      ctx.clock
+    );
+    ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
+    const serializedChanges = serializeRecord(resolvedData, ctx.definition.fields);
+    const version = serializeRowVersion(operation.timestamp);
+    const updateQuery = buildUpdateQuery(ctx.collection, id, {
+      ...serializedChanges,
+      _updated_at: operation.timestamp.wallTime,
+      _version: version
+    });
+    const opInsert = buildInsertQuery(
+      `_kora_ops_${ctx.collection}`,
+      serializeOperation(operation)
+    );
+    await tx.execute(updateQuery.sql, updateQuery.params);
+    await tx.execute(opInsert.sql, opInsert.params);
+  });
+  ctx.onMutation(ctx.collection, operation);
+  const rows = await ctx.adapter.query(
+    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    [id]
+  );
+  const row = rows[0];
+  if (!row) {
+    throw new RecordNotFoundError(ctx.collection, id);
+  }
+  return deserializeRecord(row, ctx.definition.fields);
+}
+
+// src/mutations/execute-delete.ts
+var import_core7 = require("@korajs/core");
+async function executeDelete(ctx, id, options) {
+  const currentRows = await ctx.adapter.query(
+    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    [id]
+  );
+  if (!currentRows[0]) {
+    throw new RecordNotFoundError(ctx.collection, id);
+  }
+  const causalDeps = resolveCausalDeps(ctx);
+  let operation = options?.operation;
+  const cascadedOps = [];
+  await ctx.adapter.transaction(async (tx) => {
+    if (!operation) {
+      const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
+      operation = await (0, import_core7.createOperation)(
+        {
+          nodeId: ctx.nodeId,
+          type: "delete",
+          collection: ctx.collection,
+          recordId: id,
+          data: null,
+          previousData: null,
+          sequenceNumber,
+          causalDeps,
+          schemaVersion: ctx.schema.version
+        },
+        ctx.clock
+      );
+      ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
+    }
+    if (ctx.relationEnforcer && !options?.skipReferentialEnforcement) {
+      const enforcementResult = await ctx.relationEnforcer.enforceDelete(ctx.collection, id, tx, [
+        operation.id
+      ]);
+      cascadedOps.push(...enforcementResult.operations);
+    }
+    const version = serializeRowVersion(operation.timestamp);
+    const deleteQuery = buildSoftDeleteQuery(
+      ctx.collection,
+      id,
+      operation.timestamp.wallTime,
+      version
+    );
+    const opInsert = buildInsertQuery(
+      `_kora_ops_${ctx.collection}`,
+      serializeOperation(operation)
+    );
+    await tx.execute(deleteQuery.sql, deleteQuery.params);
+    await tx.execute(opInsert.sql, opInsert.params);
+  });
+  if (!operation) {
+    throw new Error("Delete operation was not created");
+  }
+  ctx.onMutation(ctx.collection, operation);
+  for (const cascadedOp of cascadedOps) {
+    ctx.onMutation(cascadedOp.collection, cascadedOp);
+  }
+  return [operation, ...cascadedOps];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCountQuery,
+  buildInsertQuery,
+  buildLwwSoftDeleteQuery,
+  buildLwwUpdateQuery,
+  buildSelectQuery,
+  buildSoftDeleteQuery,
+  buildUpdateQuery,
+  buildWhereClause,
+  deserializeOperation,
+  deserializeOperationWithCollection,
+  deserializeRecord,
+  executeDelete,
+  executeInsert,
+  executeUpdate,
+  isIncomingNewerThanRow,
+  resolveCausalDeps,
+  rowVersionFromRecord,
+  serializeOperation,
+  serializeRecord,
+  serializeRowVersion
+});
+//# sourceMappingURL=internal.cjs.map