@korajs/store 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/chunk-YT7MRFCP.js

@@ -1,687 +0,0 @@
-import {
-  QueryError,
-  RecordNotFoundError
-} from "./chunk-TUR7RGEP.js";
-import {
-  deserializeRecord,
-  encodeRichtextFieldsForOpData,
-  serializeOperation,
-  serializeRecord
-} from "./chunk-GSJ7EEUC.js";
-
-// src/lww/row-version.ts
-import { HybridLogicalClock } from "@korajs/core";
-var EMPTY_ROW_VERSION = "";
-function serializeRowVersion(timestamp) {
-  return HybridLogicalClock.serialize(timestamp);
-}
-function rowVersionFromRecord(row) {
-  const version = row._version;
-  if (typeof version === "string" && version.length > 0) {
-    return HybridLogicalClock.deserialize(version);
-  }
-  return { wallTime: row._updated_at, logical: 0, nodeId: "" };
-}
-function isIncomingNewerThanRow(incoming, row) {
-  return HybridLogicalClock.compare(incoming, rowVersionFromRecord(row)) > 0;
-}
-function lwwVersionWhereClause(remoteVersion) {
-  return {
-    sql: "(_version = ? OR _version < ?)",
-    params: [EMPTY_ROW_VERSION, remoteVersion]
-  };
-}
-
-// src/query/sql-builder.ts
-import { quoteIdent } from "@korajs/core";
-function buildSelectQuery(descriptor, fields) {
-  const params = [];
-  const parts = [`SELECT * FROM ${quoteIdent(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 `${quoteIdent(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 ${quoteIdent(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 quotedColumns = columns.map((col) => quoteIdent(col));
-  const sql = `INSERT INTO ${quoteIdent(collection)} (${quotedColumns.join(", ")}) VALUES (${placeholders.join(", ")})`;
-  return { sql, params };
-}
-function buildUpdateQuery(collection, id, changes) {
-  const setClauses = Object.keys(changes).map((col) => `${quoteIdent(col)} = ?`);
-  const params = [...Object.values(changes), id];
-  const sql = `UPDATE ${quoteIdent(collection)} SET ${setClauses.join(", ")} WHERE id = ?`;
-  return { sql, params };
-}
-function buildFieldFastForwardUpdateQuery(collection, id, fieldChanges, remoteVersion, wallTime, options) {
-  const fieldClauses = Object.keys(fieldChanges).map((col) => `${quoteIdent(col)} = ?`);
-  const setClauses = [
-    ...fieldClauses,
-    "_version = CASE WHEN _version >= ? THEN _version ELSE ? END",
-    "_updated_at = CASE WHEN _updated_at >= ? THEN _updated_at ELSE ? END"
-  ];
-  const params = [
-    ...Object.values(fieldChanges),
-    remoteVersion,
-    remoteVersion,
-    wallTime,
-    wallTime
-  ];
-  if (options?.maxCreatedAt !== void 0) {
-    setClauses.push("_created_at = CASE WHEN _created_at >= ? THEN _created_at ELSE ? END");
-    params.push(options.maxCreatedAt, options.maxCreatedAt);
-  }
-  params.push(id);
-  const sql = `UPDATE ${quoteIdent(collection)} SET ${setClauses.join(", ")} WHERE id = ?`;
-  return { sql, params };
-}
-function buildSoftDeleteQuery(collection, id, updatedAt, version) {
-  if (version !== void 0) {
-    return {
-      sql: `UPDATE ${quoteIdent(collection)} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ?`,
-      params: [updatedAt, version, id]
-    };
-  }
-  return {
-    sql: `UPDATE ${quoteIdent(collection)} SET _deleted = 1, _updated_at = ? WHERE id = ?`,
-    params: [updatedAt, id]
-  };
-}
-function buildLwwUpdateQuery(collection, id, changes, remoteVersion) {
-  const setClauses = Object.keys(changes).map((col) => `${quoteIdent(col)} = ?`);
-  const lww = lwwVersionWhereClause(remoteVersion);
-  const sql = `UPDATE ${quoteIdent(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 ${quoteIdent(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;
-  const column = quoteIdent(fieldName);
-  switch (operator) {
-    case "$eq":
-      if (sqlValue === null) {
-        return `${column} IS NULL`;
-      }
-      params.push(sqlValue);
-      return `${column} = ?`;
-    case "$ne":
-      if (sqlValue === null) {
-        return `${column} IS NOT NULL`;
-      }
-      params.push(sqlValue);
-      return `${column} != ?`;
-    case "$gt":
-      params.push(sqlValue);
-      return `${column} > ?`;
-    case "$gte":
-      params.push(sqlValue);
-      return `${column} >= ?`;
-    case "$lt":
-      params.push(sqlValue);
-      return `${column} < ?`;
-    case "$lte":
-      params.push(sqlValue);
-      return `${column} <= ?`;
-    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 `${column} 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/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-delete.ts
-import { createOperation, quoteIdent as quoteIdent2 } from "@korajs/core";
-
-// src/store/sequence-allocator.ts
-async function allocateNextSequenceNumber(adapter, nodeId) {
-  const rows = await adapter.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}"`);
-  }
-  return seq;
-}
-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;
-}
-async function readSequenceNumber(adapter, nodeId) {
-  const rows = await adapter.query(
-    "SELECT sequence_number FROM _kora_version_vector WHERE node_id = ?",
-    [nodeId]
-  );
-  return rows[0]?.sequence_number ?? 0;
-}
-
-// src/mutations/execute-delete.ts
-async function executeDelete(ctx, id, options) {
-  const currentRows = await ctx.adapter.query(
-    `SELECT * FROM ${quoteIdent2(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 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];
-}
-
-// src/mutations/execute-insert.ts
-import {
-  createOperation as createOperation2,
-  generateUUIDv7,
-  transformSecretFieldsForWrite,
-  validateRecord
-} from "@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;
-}
-function effectiveFieldVersion(current, field, rowVersion) {
-  const own = current[field];
-  if (own !== void 0) {
-    return own;
-  }
-  return rowVersion ?? EMPTY_ROW_VERSION;
-}
-function resolvePerFieldLww(current, incomingFields, incomingVersion, rowVersion) {
-  const winners = [];
-  const merged = { ...current };
-  for (const field of incomingFields) {
-    const stored = effectiveFieldVersion(current, field, rowVersion);
-    if (incomingVersion > stored) {
-      winners.push(field);
-      merged[field] = incomingVersion;
-    }
-  }
-  return { winners, merged };
-}
-
-// src/mutations/execute-insert.ts
-async function executeInsert(ctx, data) {
-  const validated = validateRecord(ctx.collection, ctx.definition, data, "insert");
-  const recordId = generateUUIDv7();
-  for (const [fieldName, descriptor] of Object.entries(ctx.definition.fields)) {
-    if (descriptor.auto && descriptor.kind === "timestamp") {
-      validated[fieldName] = Date.now();
-    }
-  }
-  const writeData = await 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 createOperation2(
-      {
-        nodeId: ctx.nodeId,
-        type: "insert",
-        collection: ctx.collection,
-        recordId,
-        // 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,
-        schemaVersion: ctx.schema.version
-      },
-      ctx.clock
-    );
-    ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
-    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,
-      // 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(
-      `_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,
-    ...writeData,
-    createdAt: operation.timestamp.wallTime,
-    updatedAt: operation.timestamp.wallTime
-  };
-}
-
-// src/state-machine/state-validator.ts
-import { KoraError, validateTransition } from "@korajs/core";
-var InvalidStateTransitionError = class extends 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 = 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
-import {
-  createOperation as createOperation3,
-  isAtomicOp,
-  quoteIdent as quoteIdent3,
-  resolveAtomicOp,
-  toAtomicOp,
-  transformSecretFieldsForWrite as transformSecretFieldsForWrite2,
-  validateRecord as validateRecord2
-} from "@korajs/core";
-async function executeUpdate(ctx, id, data) {
-  const currentRows = await ctx.adapter.query(
-    `SELECT * FROM ${quoteIdent3(ctx.collection)} WHERE id = ? AND _deleted = 0`,
-    [id]
-  );
-  const currentRow = currentRows[0];
-  if (!currentRow) {
-    throw new RecordNotFoundError(ctx.collection, id);
-  }
-  let validated = validateRecord2(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 (isAtomicOp(value)) {
-      resolvedData[key] = resolveAtomicOp(currentRecord[key], value);
-      atomicOps[key] = toAtomicOp(value);
-    } else {
-      resolvedData[key] = value;
-    }
-  }
-  const writeData = await transformSecretFieldsForWrite2(
-    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 createOperation3(
-      {
-        nodeId: ctx.nodeId,
-        type: "update",
-        collection: ctx.collection,
-        recordId: id,
-        // 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,
-        ...hasAtomicOps ? { atomicOps } : {}
-      },
-      ctx.clock
-    );
-    ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
-    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,
-      _field_versions: serializeFieldVersions(mergedFieldVersions)
-    });
-    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 ${quoteIdent3(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);
-}
-
-export {
-  serializeRowVersion,
-  rowVersionFromRecord,
-  isIncomingNewerThanRow,
-  buildSelectQuery,
-  buildCountQuery,
-  buildInsertQuery,
-  buildUpdateQuery,
-  buildFieldFastForwardUpdateQuery,
-  buildSoftDeleteQuery,
-  buildLwwUpdateQuery,
-  buildLwwSoftDeleteQuery,
-  buildWhereClause,
-  allocateNextSequenceNumber,
-  allocateNextSequenceInTransaction,
-  readSequenceNumber,
-  resolveCausalDeps,
-  executeDelete,
-  parseFieldVersions,
-  serializeFieldVersions,
-  fieldVersionsForFields,
-  resolvePerFieldLww,
-  executeInsert,
-  InvalidStateTransitionError,
-  validateStateTransition,
-  validateUpdateStateMachine,
-  executeUpdate
-};
-//# sourceMappingURL=chunk-YT7MRFCP.js.map