@korajs/merge 0.4.0 → 0.5.0

package/dist/index.d.cts

@@ -1,4 +1,126 @@
-import { Constraint, MergeTrace, Operation, CollectionDefinition, HLCTimestamp, AtomicOp, FieldMergeStrategy, FieldDescriptor, CustomResolver, OnDeleteAction, SchemaDefinition } from '@korajs/core';
+import { OnDeleteAction, MergeTrace, SchemaDefinition, Operation, Constraint, CollectionDefinition, HLCTimestamp, AtomicOp, FieldMergeStrategy, FieldDescriptor, CustomResolver } from '@korajs/core';
+
+/**
+ * Describes an incoming relation to a target collection.
+ * Used by the delete-side referential integrity checker to know which
+ * source collections reference the collection being deleted from.
+ */
+interface MergeIncomingRelation {
+    /** Name of the relation in the schema (e.g., 'todoBelongsToProject') */
+    relationName: string;
+    /** The collection that holds the foreign key (source of the relation) */
+    sourceCollection: string;
+    /** The foreign key field in the source collection */
+    foreignKeyField: string;
+    /** What to do when the referenced record is deleted */
+    onDelete: OnDeleteAction;
+}
+/**
+ * Pluggable context for querying the database during referential integrity checks.
+ * The store layer provides the implementation; the merge package only depends on this interface.
+ */
+interface ReferentialMergeContext {
+    /** Query records in a collection matching a where clause */
+    queryRecords(collection: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    /** Check if a record exists in a collection */
+    recordExists(collection: string, recordId: string): Promise<boolean>;
+}
+/**
+ * Result of a referential integrity check on a delete operation.
+ */
+interface ReferentialCheckResult {
+    /** Whether the delete operation is allowed to proceed */
+    allowed: boolean;
+    /** Side-effect operations generated by cascade/set-null policies */
+    sideEffectOps: SideEffectOp[];
+    /** MergeTraces for every decision made (feeds DevTools) */
+    traces: MergeTrace[];
+}
+/**
+ * A side-effect operation generated during referential integrity enforcement.
+ * These are not full Operations; they describe mutations the caller must apply.
+ */
+interface SideEffectOp {
+    /** The type of mutation to apply */
+    type: 'delete' | 'update';
+    /** The collection containing the affected record */
+    collection: string;
+    /** The ID of the affected record */
+    recordId: string;
+    /** For updates: the new field values. null for deletes. */
+    data: Record<string, unknown> | null;
+    /** For updates: the previous field values. null for deletes. */
+    previousData: Record<string, unknown> | null;
+    /** The onDelete policy that produced this side effect */
+    policy: OnDeleteAction;
+    /** The relation that triggered this side effect */
+    relationName: string;
+}
+/**
+ * Result of resolving a concurrent delete-vs-insert conflict.
+ */
+interface DeleteVsInsertResolution {
+    /** Whether to block the delete or allow it */
+    action: 'block-delete' | 'allow-delete';
+    /** Any side-effect operations (for cascade/set-null after allowing delete) */
+    sideEffects: SideEffectOp[];
+    /** Trace of the resolution decision, or null if no trace needed */
+    trace: MergeTrace | null;
+}
+/**
+ * Builds a lookup map from target collection to all incoming relations.
+ *
+ * This pre-computes which collections reference a given collection via foreign keys,
+ * so that delete operations can efficiently find all relations that need enforcement.
+ *
+ * @param schema - The full schema definition with relations
+ * @returns Map from target collection name to array of incoming relations, sorted by relation name for determinism
+ *
+ * @example
+ * ```typescript
+ * const lookup = buildMergeRelationLookup(schema)
+ * // lookup.get('projects') => [{ relationName: 'todoBelongsToProject', sourceCollection: 'todos', ... }]
+ * ```
+ */
+declare function buildMergeRelationLookup(schema: SchemaDefinition): Map<string, MergeIncomingRelation[]>;
+/**
+ * Checks referential integrity when a delete operation is being applied.
+ *
+ * For each relation that targets the deleted record's collection, queries
+ * for referencing records and applies the relation's onDelete policy:
+ * - `restrict`: Blocks the delete if any references exist
+ * - `cascade`: Allows the delete and generates cascaded delete SideEffectOps
+ * - `set-null`: Allows the delete and generates update SideEffectOps to null out FKs
+ * - `no-action`: Allows the delete with no side effects (dangling references permitted)
+ *
+ * Processing is deterministic: relations are processed in sorted order by name,
+ * and referencing records within each relation are processed in sorted order by ID.
+ *
+ * @param deleteOp - The delete operation being evaluated
+ * @param schema - The full schema definition
+ * @param ctx - Database lookup context
+ * @param relationLookup - Pre-built relation lookup (optional; will be built if not provided)
+ * @returns Whether the delete is allowed, any side-effect ops, and traces for DevTools
+ */
+declare function checkReferentialIntegrityOnDelete(deleteOp: Operation, schema: SchemaDefinition, ctx: ReferentialMergeContext, relationLookup?: Map<string, MergeIncomingRelation[]>): Promise<ReferentialCheckResult>;
+/**
+ * Resolves a concurrent delete-vs-insert conflict on a referenced record.
+ *
+ * When one node deletes a record while another concurrently inserts a record
+ * that references the deleted record, we need to decide what wins.
+ *
+ * Resolution strategy depends on the relation's onDelete policy:
+ * - `restrict`: Block the delete (the insert wins — data integrity preserved)
+ * - `cascade`: Allow the delete and cascade-delete the newly inserted record
+ * - `set-null`: Allow the delete and null out the FK on the newly inserted record
+ * - `no-action`: Allow the delete (dangling reference is acceptable)
+ *
+ * @param deleteOp - The delete operation on the referenced record
+ * @param insertOp - The concurrent insert operation that references the deleted record
+ * @param relation - The relation definition connecting the two collections
+ * @returns The resolution action, side effects, and trace
+ */
+declare function resolveDeleteVsInsertConflict(deleteOp: Operation, insertOp: Operation, relation: MergeIncomingRelation): DeleteVsInsertResolution;
 
 /**
  * Input to the merge engine when two concurrent operations conflict.
@@ -23,6 +145,12 @@ interface MergeResult {
     traces: MergeTrace[];
     /** Which operation's values dominate overall, or 'merged' if mixed */
     appliedOperation: 'local' | 'remote' | 'merged';
+    /**
+     * Side-effect operations generated during constraint resolution
+     * (e.g., cascade deletes, set-null updates from referential integrity).
+     * These must be applied by the caller after the merge.
+     */
+    sideEffects: SideEffectOp[];
 }
 /**
  * Output of a single field-level merge decision.
@@ -249,6 +377,12 @@ interface ConstraintResolution {
     resolvedRecord: Record<string, unknown>;
     /** Trace of the resolution decision for DevTools */
     trace: MergeTrace;
+    /**
+     * Side-effect operations generated during resolution
+     * (e.g., referring record updates for referential integrity).
+     * Empty unless the constraint resolver generates cascading actions.
+     */
+    sideEffects?: SideEffectOp[];
 }
 /**
  * Resolves a constraint violation by applying the constraint's onConflict strategy.
@@ -269,128 +403,6 @@ interface ConstraintResolution {
  */
 declare function resolveConstraintViolation(violation: ConstraintViolation, mergedRecord: Record<string, unknown>, localOp: Operation, remoteOp: Operation, baseState: Record<string, unknown>): ConstraintResolution;
 
-/**
- * Describes an incoming relation to a target collection.
- * Used by the delete-side referential integrity checker to know which
- * source collections reference the collection being deleted from.
- */
-interface MergeIncomingRelation {
-    /** Name of the relation in the schema (e.g., 'todoBelongsToProject') */
-    relationName: string;
-    /** The collection that holds the foreign key (source of the relation) */
-    sourceCollection: string;
-    /** The foreign key field in the source collection */
-    foreignKeyField: string;
-    /** What to do when the referenced record is deleted */
-    onDelete: OnDeleteAction;
-}
-/**
- * Pluggable context for querying the database during referential integrity checks.
- * The store layer provides the implementation; the merge package only depends on this interface.
- */
-interface ReferentialMergeContext {
-    /** Query records in a collection matching a where clause */
-    queryRecords(collection: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;
-    /** Check if a record exists in a collection */
-    recordExists(collection: string, recordId: string): Promise<boolean>;
-}
-/**
- * Result of a referential integrity check on a delete operation.
- */
-interface ReferentialCheckResult {
-    /** Whether the delete operation is allowed to proceed */
-    allowed: boolean;
-    /** Side-effect operations generated by cascade/set-null policies */
-    sideEffectOps: SideEffectOp[];
-    /** MergeTraces for every decision made (feeds DevTools) */
-    traces: MergeTrace[];
-}
-/**
- * A side-effect operation generated during referential integrity enforcement.
- * These are not full Operations; they describe mutations the caller must apply.
- */
-interface SideEffectOp {
-    /** The type of mutation to apply */
-    type: 'delete' | 'update';
-    /** The collection containing the affected record */
-    collection: string;
-    /** The ID of the affected record */
-    recordId: string;
-    /** For updates: the new field values. null for deletes. */
-    data: Record<string, unknown> | null;
-    /** For updates: the previous field values. null for deletes. */
-    previousData: Record<string, unknown> | null;
-    /** The onDelete policy that produced this side effect */
-    policy: OnDeleteAction;
-    /** The relation that triggered this side effect */
-    relationName: string;
-}
-/**
- * Result of resolving a concurrent delete-vs-insert conflict.
- */
-interface DeleteVsInsertResolution {
-    /** Whether to block the delete or allow it */
-    action: 'block-delete' | 'allow-delete';
-    /** Any side-effect operations (for cascade/set-null after allowing delete) */
-    sideEffects: SideEffectOp[];
-    /** Trace of the resolution decision, or null if no trace needed */
-    trace: MergeTrace | null;
-}
-/**
- * Builds a lookup map from target collection to all incoming relations.
- *
- * This pre-computes which collections reference a given collection via foreign keys,
- * so that delete operations can efficiently find all relations that need enforcement.
- *
- * @param schema - The full schema definition with relations
- * @returns Map from target collection name to array of incoming relations, sorted by relation name for determinism
- *
- * @example
- * ```typescript
- * const lookup = buildMergeRelationLookup(schema)
- * // lookup.get('projects') => [{ relationName: 'todoBelongsToProject', sourceCollection: 'todos', ... }]
- * ```
- */
-declare function buildMergeRelationLookup(schema: SchemaDefinition): Map<string, MergeIncomingRelation[]>;
-/**
- * Checks referential integrity when a delete operation is being applied.
- *
- * For each relation that targets the deleted record's collection, queries
- * for referencing records and applies the relation's onDelete policy:
- * - `restrict`: Blocks the delete if any references exist
- * - `cascade`: Allows the delete and generates cascaded delete SideEffectOps
- * - `set-null`: Allows the delete and generates update SideEffectOps to null out FKs
- * - `no-action`: Allows the delete with no side effects (dangling references permitted)
- *
- * Processing is deterministic: relations are processed in sorted order by name,
- * and referencing records within each relation are processed in sorted order by ID.
- *
- * @param deleteOp - The delete operation being evaluated
- * @param schema - The full schema definition
- * @param ctx - Database lookup context
- * @param relationLookup - Pre-built relation lookup (optional; will be built if not provided)
- * @returns Whether the delete is allowed, any side-effect ops, and traces for DevTools
- */
-declare function checkReferentialIntegrityOnDelete(deleteOp: Operation, schema: SchemaDefinition, ctx: ReferentialMergeContext, relationLookup?: Map<string, MergeIncomingRelation[]>): Promise<ReferentialCheckResult>;
-/**
- * Resolves a concurrent delete-vs-insert conflict on a referenced record.
- *
- * When one node deletes a record while another concurrently inserts a record
- * that references the deleted record, we need to decide what wins.
- *
- * Resolution strategy depends on the relation's onDelete policy:
- * - `restrict`: Block the delete (the insert wins — data integrity preserved)
- * - `cascade`: Allow the delete and cascade-delete the newly inserted record
- * - `set-null`: Allow the delete and null out the FK on the newly inserted record
- * - `no-action`: Allow the delete (dangling reference is acceptable)
- *
- * @param deleteOp - The delete operation on the referenced record
- * @param insertOp - The concurrent insert operation that references the deleted record
- * @param relation - The relation definition connecting the two collections
- * @returns The resolution action, side effects, and trace
- */
-declare function resolveDeleteVsInsertConflict(deleteOp: Operation, insertOp: Operation, relation: MergeIncomingRelation): DeleteVsInsertResolution;
-
 /**
  * Three-tier merge engine for resolving concurrent operations.
  *

package/dist/index.d.ts

@@ -1,4 +1,126 @@
-import { Constraint, MergeTrace, Operation, CollectionDefinition, HLCTimestamp, AtomicOp, FieldMergeStrategy, FieldDescriptor, CustomResolver, OnDeleteAction, SchemaDefinition } from '@korajs/core';
+import { OnDeleteAction, MergeTrace, SchemaDefinition, Operation, Constraint, CollectionDefinition, HLCTimestamp, AtomicOp, FieldMergeStrategy, FieldDescriptor, CustomResolver } from '@korajs/core';
+
+/**
+ * Describes an incoming relation to a target collection.
+ * Used by the delete-side referential integrity checker to know which
+ * source collections reference the collection being deleted from.
+ */
+interface MergeIncomingRelation {
+    /** Name of the relation in the schema (e.g., 'todoBelongsToProject') */
+    relationName: string;
+    /** The collection that holds the foreign key (source of the relation) */
+    sourceCollection: string;
+    /** The foreign key field in the source collection */
+    foreignKeyField: string;
+    /** What to do when the referenced record is deleted */
+    onDelete: OnDeleteAction;
+}
+/**
+ * Pluggable context for querying the database during referential integrity checks.
+ * The store layer provides the implementation; the merge package only depends on this interface.
+ */
+interface ReferentialMergeContext {
+    /** Query records in a collection matching a where clause */
+    queryRecords(collection: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    /** Check if a record exists in a collection */
+    recordExists(collection: string, recordId: string): Promise<boolean>;
+}
+/**
+ * Result of a referential integrity check on a delete operation.
+ */
+interface ReferentialCheckResult {
+    /** Whether the delete operation is allowed to proceed */
+    allowed: boolean;
+    /** Side-effect operations generated by cascade/set-null policies */
+    sideEffectOps: SideEffectOp[];
+    /** MergeTraces for every decision made (feeds DevTools) */
+    traces: MergeTrace[];
+}
+/**
+ * A side-effect operation generated during referential integrity enforcement.
+ * These are not full Operations; they describe mutations the caller must apply.
+ */
+interface SideEffectOp {
+    /** The type of mutation to apply */
+    type: 'delete' | 'update';
+    /** The collection containing the affected record */
+    collection: string;
+    /** The ID of the affected record */
+    recordId: string;
+    /** For updates: the new field values. null for deletes. */
+    data: Record<string, unknown> | null;
+    /** For updates: the previous field values. null for deletes. */
+    previousData: Record<string, unknown> | null;
+    /** The onDelete policy that produced this side effect */
+    policy: OnDeleteAction;
+    /** The relation that triggered this side effect */
+    relationName: string;
+}
+/**
+ * Result of resolving a concurrent delete-vs-insert conflict.
+ */
+interface DeleteVsInsertResolution {
+    /** Whether to block the delete or allow it */
+    action: 'block-delete' | 'allow-delete';
+    /** Any side-effect operations (for cascade/set-null after allowing delete) */
+    sideEffects: SideEffectOp[];
+    /** Trace of the resolution decision, or null if no trace needed */
+    trace: MergeTrace | null;
+}
+/**
+ * Builds a lookup map from target collection to all incoming relations.
+ *
+ * This pre-computes which collections reference a given collection via foreign keys,
+ * so that delete operations can efficiently find all relations that need enforcement.
+ *
+ * @param schema - The full schema definition with relations
+ * @returns Map from target collection name to array of incoming relations, sorted by relation name for determinism
+ *
+ * @example
+ * ```typescript
+ * const lookup = buildMergeRelationLookup(schema)
+ * // lookup.get('projects') => [{ relationName: 'todoBelongsToProject', sourceCollection: 'todos', ... }]
+ * ```
+ */
+declare function buildMergeRelationLookup(schema: SchemaDefinition): Map<string, MergeIncomingRelation[]>;
+/**
+ * Checks referential integrity when a delete operation is being applied.
+ *
+ * For each relation that targets the deleted record's collection, queries
+ * for referencing records and applies the relation's onDelete policy:
+ * - `restrict`: Blocks the delete if any references exist
+ * - `cascade`: Allows the delete and generates cascaded delete SideEffectOps
+ * - `set-null`: Allows the delete and generates update SideEffectOps to null out FKs
+ * - `no-action`: Allows the delete with no side effects (dangling references permitted)
+ *
+ * Processing is deterministic: relations are processed in sorted order by name,
+ * and referencing records within each relation are processed in sorted order by ID.
+ *
+ * @param deleteOp - The delete operation being evaluated
+ * @param schema - The full schema definition
+ * @param ctx - Database lookup context
+ * @param relationLookup - Pre-built relation lookup (optional; will be built if not provided)
+ * @returns Whether the delete is allowed, any side-effect ops, and traces for DevTools
+ */
+declare function checkReferentialIntegrityOnDelete(deleteOp: Operation, schema: SchemaDefinition, ctx: ReferentialMergeContext, relationLookup?: Map<string, MergeIncomingRelation[]>): Promise<ReferentialCheckResult>;
+/**
+ * Resolves a concurrent delete-vs-insert conflict on a referenced record.
+ *
+ * When one node deletes a record while another concurrently inserts a record
+ * that references the deleted record, we need to decide what wins.
+ *
+ * Resolution strategy depends on the relation's onDelete policy:
+ * - `restrict`: Block the delete (the insert wins — data integrity preserved)
+ * - `cascade`: Allow the delete and cascade-delete the newly inserted record
+ * - `set-null`: Allow the delete and null out the FK on the newly inserted record
+ * - `no-action`: Allow the delete (dangling reference is acceptable)
+ *
+ * @param deleteOp - The delete operation on the referenced record
+ * @param insertOp - The concurrent insert operation that references the deleted record
+ * @param relation - The relation definition connecting the two collections
+ * @returns The resolution action, side effects, and trace
+ */
+declare function resolveDeleteVsInsertConflict(deleteOp: Operation, insertOp: Operation, relation: MergeIncomingRelation): DeleteVsInsertResolution;
 
 /**
  * Input to the merge engine when two concurrent operations conflict.
@@ -23,6 +145,12 @@ interface MergeResult {
     traces: MergeTrace[];
     /** Which operation's values dominate overall, or 'merged' if mixed */
     appliedOperation: 'local' | 'remote' | 'merged';
+    /**
+     * Side-effect operations generated during constraint resolution
+     * (e.g., cascade deletes, set-null updates from referential integrity).
+     * These must be applied by the caller after the merge.
+     */
+    sideEffects: SideEffectOp[];
 }
 /**
  * Output of a single field-level merge decision.
@@ -249,6 +377,12 @@ interface ConstraintResolution {
     resolvedRecord: Record<string, unknown>;
     /** Trace of the resolution decision for DevTools */
     trace: MergeTrace;
+    /**
+     * Side-effect operations generated during resolution
+     * (e.g., referring record updates for referential integrity).
+     * Empty unless the constraint resolver generates cascading actions.
+     */
+    sideEffects?: SideEffectOp[];
 }
 /**
  * Resolves a constraint violation by applying the constraint's onConflict strategy.
@@ -269,128 +403,6 @@ interface ConstraintResolution {
  */
 declare function resolveConstraintViolation(violation: ConstraintViolation, mergedRecord: Record<string, unknown>, localOp: Operation, remoteOp: Operation, baseState: Record<string, unknown>): ConstraintResolution;
 
-/**
- * Describes an incoming relation to a target collection.
- * Used by the delete-side referential integrity checker to know which
- * source collections reference the collection being deleted from.
- */
-interface MergeIncomingRelation {
-    /** Name of the relation in the schema (e.g., 'todoBelongsToProject') */
-    relationName: string;
-    /** The collection that holds the foreign key (source of the relation) */
-    sourceCollection: string;
-    /** The foreign key field in the source collection */
-    foreignKeyField: string;
-    /** What to do when the referenced record is deleted */
-    onDelete: OnDeleteAction;
-}
-/**
- * Pluggable context for querying the database during referential integrity checks.
- * The store layer provides the implementation; the merge package only depends on this interface.
- */
-interface ReferentialMergeContext {
-    /** Query records in a collection matching a where clause */
-    queryRecords(collection: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;
-    /** Check if a record exists in a collection */
-    recordExists(collection: string, recordId: string): Promise<boolean>;
-}
-/**
- * Result of a referential integrity check on a delete operation.
- */
-interface ReferentialCheckResult {
-    /** Whether the delete operation is allowed to proceed */
-    allowed: boolean;
-    /** Side-effect operations generated by cascade/set-null policies */
-    sideEffectOps: SideEffectOp[];
-    /** MergeTraces for every decision made (feeds DevTools) */
-    traces: MergeTrace[];
-}
-/**
- * A side-effect operation generated during referential integrity enforcement.
- * These are not full Operations; they describe mutations the caller must apply.
- */
-interface SideEffectOp {
-    /** The type of mutation to apply */
-    type: 'delete' | 'update';
-    /** The collection containing the affected record */
-    collection: string;
-    /** The ID of the affected record */
-    recordId: string;
-    /** For updates: the new field values. null for deletes. */
-    data: Record<string, unknown> | null;
-    /** For updates: the previous field values. null for deletes. */
-    previousData: Record<string, unknown> | null;
-    /** The onDelete policy that produced this side effect */
-    policy: OnDeleteAction;
-    /** The relation that triggered this side effect */
-    relationName: string;
-}
-/**
- * Result of resolving a concurrent delete-vs-insert conflict.
- */
-interface DeleteVsInsertResolution {
-    /** Whether to block the delete or allow it */
-    action: 'block-delete' | 'allow-delete';
-    /** Any side-effect operations (for cascade/set-null after allowing delete) */
-    sideEffects: SideEffectOp[];
-    /** Trace of the resolution decision, or null if no trace needed */
-    trace: MergeTrace | null;
-}
-/**
- * Builds a lookup map from target collection to all incoming relations.
- *
- * This pre-computes which collections reference a given collection via foreign keys,
- * so that delete operations can efficiently find all relations that need enforcement.
- *
- * @param schema - The full schema definition with relations
- * @returns Map from target collection name to array of incoming relations, sorted by relation name for determinism
- *
- * @example
- * ```typescript
- * const lookup = buildMergeRelationLookup(schema)
- * // lookup.get('projects') => [{ relationName: 'todoBelongsToProject', sourceCollection: 'todos', ... }]
- * ```
- */
-declare function buildMergeRelationLookup(schema: SchemaDefinition): Map<string, MergeIncomingRelation[]>;
-/**
- * Checks referential integrity when a delete operation is being applied.
- *
- * For each relation that targets the deleted record's collection, queries
- * for referencing records and applies the relation's onDelete policy:
- * - `restrict`: Blocks the delete if any references exist
- * - `cascade`: Allows the delete and generates cascaded delete SideEffectOps
- * - `set-null`: Allows the delete and generates update SideEffectOps to null out FKs
- * - `no-action`: Allows the delete with no side effects (dangling references permitted)
- *
- * Processing is deterministic: relations are processed in sorted order by name,
- * and referencing records within each relation are processed in sorted order by ID.
- *
- * @param deleteOp - The delete operation being evaluated
- * @param schema - The full schema definition
- * @param ctx - Database lookup context
- * @param relationLookup - Pre-built relation lookup (optional; will be built if not provided)
- * @returns Whether the delete is allowed, any side-effect ops, and traces for DevTools
- */
-declare function checkReferentialIntegrityOnDelete(deleteOp: Operation, schema: SchemaDefinition, ctx: ReferentialMergeContext, relationLookup?: Map<string, MergeIncomingRelation[]>): Promise<ReferentialCheckResult>;
-/**
- * Resolves a concurrent delete-vs-insert conflict on a referenced record.
- *
- * When one node deletes a record while another concurrently inserts a record
- * that references the deleted record, we need to decide what wins.
- *
- * Resolution strategy depends on the relation's onDelete policy:
- * - `restrict`: Block the delete (the insert wins — data integrity preserved)
- * - `cascade`: Allow the delete and cascade-delete the newly inserted record
- * - `set-null`: Allow the delete and null out the FK on the newly inserted record
- * - `no-action`: Allow the delete (dangling reference is acceptable)
- *
- * @param deleteOp - The delete operation on the referenced record
- * @param insertOp - The concurrent insert operation that references the deleted record
- * @param relation - The relation definition connecting the two collections
- * @returns The resolution action, side effects, and trace
- */
-declare function resolveDeleteVsInsertConflict(deleteOp: Operation, insertOp: Operation, relation: MergeIncomingRelation): DeleteVsInsertResolution;
-
 /**
  * Three-tier merge engine for resolving concurrent operations.
  *

package/dist/index.js

@@ -1172,7 +1172,8 @@ var MergeEngine = class {
       return {
         mergedData: {},
         traces: [],
-        appliedOperation: "merged"
+        appliedOperation: "merged",
+        sideEffects: []
       };
     }
     if (input.local.type === "delete" || input.remote.type === "delete") {
@@ -1190,6 +1191,7 @@ var MergeEngine = class {
       );
       let mergedData = fieldResult.mergedData;
       const allTraces = [...fieldResult.traces];
+      const allSideEffects = [...fieldResult.sideEffects];
       for (const violation of violations) {
         const resolution = resolveConstraintViolation(
           violation,
@@ -1200,11 +1202,15 @@ var MergeEngine = class {
         );
         mergedData = resolution.resolvedRecord;
         allTraces.push(resolution.trace);
+        if (resolution.sideEffects) {
+          allSideEffects.push(...resolution.sideEffects);
+        }
       }
       return {
         mergedData,
         traces: allTraces,
-        appliedOperation: determineAppliedOperation(allTraces)
+        appliedOperation: determineAppliedOperation(allTraces),
+        sideEffects: allSideEffects
       };
     }
     return fieldResult;
@@ -1252,7 +1258,8 @@ var MergeEngine = class {
     return {
       mergedData,
       traces,
-      appliedOperation: determineAppliedOperation(traces)
+      appliedOperation: determineAppliedOperation(traces),
+      sideEffects: []
     };
   }
   /**
@@ -1264,21 +1271,23 @@ var MergeEngine = class {
     const comparison = HybridLogicalClock6.compare(local.timestamp, remote.timestamp);
     if (comparison >= 0) {
       if (local.type === "delete") {
-        return { mergedData: {}, traces: [], appliedOperation: "local" };
+        return { mergedData: {}, traces: [], appliedOperation: "local", sideEffects: [] };
       }
       return {
         mergedData: { ...input.baseState, ...local.data ?? {} },
         traces: [],
-        appliedOperation: "local"
+        appliedOperation: "local",
+        sideEffects: []
       };
     }
     if (remote.type === "delete") {
-      return { mergedData: {}, traces: [], appliedOperation: "remote" };
+      return { mergedData: {}, traces: [], appliedOperation: "remote", sideEffects: [] };
     }
     return {
       mergedData: { ...input.baseState, ...remote.data ?? {} },
       traces: [],
-      appliedOperation: "remote"
+      appliedOperation: "remote",
+      sideEffects: []
     };
   }
 };