@recordtimelabel/core 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recordtimelabel/core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "Shared RecordTimeLabel data model, merge logic, operations, and sync engine.",
   "main": "./src/index.js",

package/src/index.js

@@ -21,6 +21,13 @@ export const OPERATION_TYPES = Object.freeze({
   EXPANDED_GROUPS_UPDATE: 'expandedGroups.update',
   SETTINGS_UPDATE: 'settings.update'
 });
+
+const ORDER_OPERATION_TYPES = new Set([
+  OPERATION_TYPES.RECORD_REORDER,
+  OPERATION_TYPES.FOLDER_REORDER,
+  OPERATION_TYPES.GROUP_REORDER,
+  OPERATION_TYPES.EXPANDED_GROUPS_UPDATE
+]);
 
 export const RECORD_TIMELABEL_SYNC_MODES = Object.freeze({
   FULL: 'full',
@@ -514,15 +521,53 @@ export const preserveRecordOrderFromLocal = (records = {}, localRecords = {}) =>
   return result;
 };
 
-export const createOperation = (type, payload = {}, options = {}) => ({
-  id: options.id || `${type}:${options.clientId || 'client'}:${options.now || Date.now()}:${Math.random().toString(36).slice(2, 10)}`,
-  type,
-  payload,
-  clientId: options.clientId || null,
-  createdAt: options.now || Date.now()
-});
-
-export const applyOperation = (state = {}, operation = {}) => {
+export const createOperation = (type, payload = {}, options = {}) => ({
+  id: options.id || `${type}:${options.clientId || 'client'}:${options.now || Date.now()}:${Math.random().toString(36).slice(2, 10)}`,
+  type,
+  payload,
+  clientId: options.clientId || null,
+  createdAt: options.now || Date.now()
+});
+
+const getOperationClientInstanceId = (operation = {}, payload = {}) => (
+  operation.clientInstanceId ||
+  operation.instanceId ||
+  payload.clientInstanceId ||
+  payload.instanceId ||
+  null
+);
+
+const buildOperationSyncMeta = (previousSyncMeta = {}, operation = {}, payload = {}, operationTime) => {
+  const nextSyncMeta = {
+    ...(previousSyncMeta || {}),
+    lastOperationId: operation.id || previousSyncMeta?.lastOperationId || null,
+    lastOperationType: operation.type || previousSyncMeta?.lastOperationType || null,
+    lastClientId: operation.clientId || previousSyncMeta?.lastClientId || null,
+    lastOperationAt: operationTime
+  };
+  const nextClientInstanceId = getOperationClientInstanceId(operation, payload);
+
+  if (nextClientInstanceId) {
+    nextSyncMeta.lastClientInstanceId = nextClientInstanceId;
+  } else if (operation.clientId) {
+    delete nextSyncMeta.lastClientInstanceId;
+  }
+
+  if (ORDER_OPERATION_TYPES.has(operation.type)) {
+    nextSyncMeta.lastOrderOperationAtByType = {
+      ...(previousSyncMeta?.lastOrderOperationAtByType || {}),
+      [operation.type]: operationTime
+    };
+    nextSyncMeta.lastOrderOperationIdByType = {
+      ...(previousSyncMeta?.lastOrderOperationIdByType || {}),
+      [operation.type]: operation.id || null
+    };
+  }
+
+  return nextSyncMeta;
+};
+
+export const applyOperation = (state = {}, operation = {}) => {
   const normalized = normalizeState(state);
   const type = operation.type;
   const payload = operation.payload || {};
@@ -723,16 +768,15 @@ export const applyOperation = (state = {}, operation = {}) => {
 
     default:
       return normalized;
-  }
-
-  nextState.lastModified = Math.max(nextState.lastModified || 0, operationTime);
-  nextState.rtlSyncMeta = {
-    ...nextState.rtlSyncMeta,
-    lastOperationId: operation.id || nextState.rtlSyncMeta.lastOperationId || null,
-    lastOperationType: operation.type || nextState.rtlSyncMeta.lastOperationType || null,
-    lastClientId: operation.clientId || nextState.rtlSyncMeta.lastClientId || null,
-    lastOperationAt: operationTime
-  };
+  }
+
+  nextState.lastModified = Math.max(nextState.lastModified || 0, operationTime);
+  nextState.rtlSyncMeta = buildOperationSyncMeta(
+    nextState.rtlSyncMeta,
+    operation,
+    payload,
+    operationTime
+  );
 
   return normalizeState(nextState);
 };
@@ -989,6 +1033,146 @@ const mapValuesArray = (value = {}) => {
   return Object.values(value);
 };
 
+const buildLiveV2RecordIdsByFolder = (recordDocuments = {}) => {
+  const liveRecordIdsByFolder = {};
+  const liveRecordIdSetsByFolder = {};
+
+  Object.values(recordDocuments || {}).forEach((recordDoc) => {
+    const recordId = normalizeId(recordDoc?.id);
+    const folderId = safeFolderId(recordDoc?.folderId);
+    if (!recordId) return;
+
+    if (!liveRecordIdsByFolder[folderId]) {
+      liveRecordIdsByFolder[folderId] = [];
+      liveRecordIdSetsByFolder[folderId] = new Set();
+    }
+
+    if (liveRecordIdSetsByFolder[folderId].has(recordId)) return;
+    liveRecordIdSetsByFolder[folderId].add(recordId);
+    liveRecordIdsByFolder[folderId].push(recordId);
+  });
+
+  return {
+    liveRecordIdsByFolder,
+    liveRecordIdSetsByFolder
+  };
+};
+
+const buildV2RecordOrderByFolder = (records = {}, recordDocuments = {}) => {
+  const {
+    liveRecordIdsByFolder,
+    liveRecordIdSetsByFolder
+  } = buildLiveV2RecordIdsByFolder(recordDocuments);
+  const hasLiveRecordDocuments = Object.keys(recordDocuments || {}).length > 0;
+  const orders = {};
+  const seenByFolder = {};
+
+  Object.keys(liveRecordIdsByFolder).forEach((folderId) => {
+    orders[folderId] = [];
+    seenByFolder[folderId] = new Set();
+  });
+
+  Object.entries(records || {}).forEach(([folderId, folderRecords]) => {
+    const normalizedFolderId = safeFolderId(folderId);
+    if (hasLiveRecordDocuments && !liveRecordIdSetsByFolder[normalizedFolderId]) return;
+
+    const seen = seenByFolder[normalizedFolderId] || new Set();
+    orders[normalizedFolderId] = orders[normalizedFolderId] || [];
+
+    toArray(folderRecords).forEach((record) => {
+      const recordId = normalizeId(record?.id);
+      if (!recordId || seen.has(recordId)) return;
+      if (
+        liveRecordIdSetsByFolder[normalizedFolderId] &&
+        !liveRecordIdSetsByFolder[normalizedFolderId].has(recordId)
+      ) {
+        return;
+      }
+
+      seen.add(recordId);
+      orders[normalizedFolderId].push(recordId);
+    });
+
+    seenByFolder[normalizedFolderId] = seen;
+  });
+
+  Object.entries(liveRecordIdsByFolder).forEach(([folderId, liveRecordIds]) => {
+    const seen = seenByFolder[folderId] || new Set();
+    orders[folderId] = orders[folderId] || [];
+
+    liveRecordIds.forEach((recordId) => {
+      if (seen.has(recordId)) return;
+      seen.add(recordId);
+      orders[folderId].push(recordId);
+    });
+  });
+
+  return orders;
+};
+
+const extractV2RecordOrderByFolder = (folderDocuments = {}) => {
+  const orders = {};
+
+  Object.entries(folderDocuments || {}).forEach(([rawFolderId, folderDoc]) => {
+    const folderId = normalizeId(folderDoc?.id || rawFolderId);
+    if (!folderId || !Array.isArray(folderDoc?.recordOrder)) return;
+
+    const seen = new Set();
+    orders[folderId] = [];
+
+    folderDoc.recordOrder.forEach((recordId) => {
+      const normalized = normalizeId(recordId);
+      if (!normalized || seen.has(normalized)) return;
+      seen.add(normalized);
+      orders[folderId].push(normalized);
+    });
+  });
+
+  return orders;
+};
+
+const reorderV2RecordsByFolderRecordOrder = (records = {}, recordOrderByFolder = {}) => {
+  const nextRecords = {};
+
+  Object.entries(records || {}).forEach(([folderId, folderRecords]) => {
+    const fallbackRecords = toArray(folderRecords);
+    const recordOrder = recordOrderByFolder[folderId];
+
+    if (!Array.isArray(recordOrder)) {
+      nextRecords[folderId] = fallbackRecords;
+      return;
+    }
+
+    const recordsById = new Map();
+    fallbackRecords.forEach((record) => {
+      const recordId = normalizeId(record?.id);
+      if (recordId && !recordsById.has(recordId)) {
+        recordsById.set(recordId, { ...record, id: recordId });
+      }
+    });
+
+    const seen = new Set();
+    const orderedRecords = [];
+    recordOrder.forEach((recordId) => {
+      const record = recordsById.get(recordId);
+      if (!record || seen.has(recordId)) return;
+      seen.add(recordId);
+      orderedRecords.push(record);
+    });
+
+    fallbackRecords.forEach((record) => {
+      const recordId = normalizeId(record?.id);
+      if (!recordId || seen.has(recordId)) return;
+      seen.add(recordId);
+      orderedRecords.push(record);
+    });
+
+    nextRecords[folderId] = orderedRecords;
+  });
+
+  return nextRecords;
+};
+
 const cleanV2RecordDocument = (record = {}, folderId, now) => {
   const recordId = normalizeId(record.id);
   if (!recordId) return null;
@@ -1005,8 +1189,15 @@ const cleanV2RecordDocument = (record = {}, folderId, now) => {
 const cleanV2FolderDocument = (folder = {}, now) => {
   const folderId = normalizeId(folder.id);
   if (!folderId) return null;
+  const {
+    schemaVersion,
+    recordOrder,
+    groupOrder,
+    folderOrder,
+    ...folderFields
+  } = folder || {};
   return {
-    ...folder,
+    ...folderFields,
     id: folderId,
     updatedAt: folder.updatedAt || folder.createdAt || now,
     schemaVersion: 2
@@ -1035,10 +1226,16 @@ export const buildFirestoreV2DocumentsFromState = (state = {}, options = {}) =>
     });
   });
 
+  const recordOrderByFolder = buildV2RecordOrderByFolder(normalized.records || {}, records);
   const folders = {};
   toArray(normalized.folders).forEach((folder) => {
     const folderDoc = cleanV2FolderDocument(folder, now);
-    if (folderDoc) folders[folderDoc.id] = folderDoc;
+    if (folderDoc) {
+      folders[folderDoc.id] = {
+        ...folderDoc,
+        recordOrder: recordOrderByFolder[folderDoc.id] || []
+      };
+    }
   });
 
   const ops = {};
@@ -1094,11 +1291,12 @@ export const buildStateFromFirestoreV2Documents = (documents = {}, options = {})
     ];
   });
 
+  const recordOrderByFolder = extractV2RecordOrderByFolder(documents?.folders);
   const folders = mapValuesArray(documents?.folders)
     .map((folderDoc) => {
       const folderId = normalizeId(folderDoc?.id);
       if (!folderId) return null;
-      const { schemaVersion, ...folder } = folderDoc;
+      const { schemaVersion, recordOrder, groupOrder, folderOrder, ...folder } = folderDoc;
       return { ...folder, id: folderId };
     })
     .filter(Boolean);
@@ -1114,7 +1312,7 @@ export const buildStateFromFirestoreV2Documents = (documents = {}, options = {})
 
   const state = normalizeState({
     folders,
-    records,
+    records: reorderV2RecordsByFolderRecordOrder(records, recordOrderByFolder),
     settings: rootDoc.settings || {},
     groupOrder: normalizeGroupOrderForOption(rootDoc.groupOrder, options.groupOrderNormalizer),
     folderOrder: rootDoc.folderOrder || [],
@@ -1180,6 +1378,12 @@ const getLastLocalOperationType = (data = {}) => String(
   ''
 );
 
+const getLastRemoteOperationType = (data = {}) => String(
+  data?.rtlSyncMeta?.lastOperationType ||
+  data?.syncMeta?.lastRemoteOperationType ||
+  ''
+);
+
 const getLastLocalOperationAt = (data = {}) => toFiniteTimestamp(
   data?.rtlSyncMeta?.lastOperationAt ||
   data?.rtlSyncMeta?.lastLocalOperationAt ||
@@ -1193,23 +1397,70 @@ const getLastRemoteOperationAt = (data = {}) => toFiniteTimestamp(
   data?.lastModified
 );
 
+const getLastClientId = (data = {}) => String(
+  data?.rtlSyncMeta?.lastClientId ||
+  data?.syncMeta?.lastClientId ||
+  data?.syncMeta?.lastMergedClientId ||
+  ''
+);
+
+const getOrderOperationAtByType = (data = {}, operationType) => toFiniteTimestamp(
+  data?.rtlSyncMeta?.lastOrderOperationAtByType?.[operationType] ||
+  data?.syncMeta?.lastOrderOperationAtByType?.[operationType]
+);
+
+const hasOperationMarker = (data = {}, operationType, operationTypeResolver = getLastRemoteOperationType) => {
+  const lastOperationId = String(data?.rtlSyncMeta?.lastOperationId || '');
+  const lastOperationType = operationTypeResolver(data);
+  return lastOperationId.startsWith(`${operationType}:`) || lastOperationType === operationType;
+};
+
+const getMarkedOrderOperationAt = (data = {}, operationType, {
+  operationTypeResolver = getLastRemoteOperationType,
+  operationAtResolver = getLastRemoteOperationAt
+} = {}) => {
+  const operationAtByType = getOrderOperationAtByType(data, operationType);
+  if (operationAtByType) return operationAtByType;
+  return hasOperationMarker(data, operationType, operationTypeResolver)
+    ? operationAtResolver(data)
+    : 0;
+};
+
 const hasRecentLocalOperation = (localData = {}, remoteData = {}, operationType) => {
-  const lastOperationId = String(localData?.rtlSyncMeta?.lastOperationId || '');
-  const lastOperationType = getLastLocalOperationType(localData);
-  if (!lastOperationId.startsWith(`${operationType}:`) && lastOperationType !== operationType) {
+  const localOperationAt = getMarkedOrderOperationAt(localData, operationType, {
+    operationTypeResolver: getLastLocalOperationType,
+    operationAtResolver: getLastLocalOperationAt
+  });
+  if (!localOperationAt) {
     return false;
   }
 
-  const localOperationAt = getLastLocalOperationAt(localData);
-  const remoteOperationAt = getLastRemoteOperationAt(remoteData);
+  const remoteOrderOperationAt = getMarkedOrderOperationAt(remoteData, operationType, {
+    operationTypeResolver: getLastRemoteOperationType,
+    operationAtResolver: getLastRemoteOperationAt
+  });
+  const remoteOperationAt = remoteOrderOperationAt || getLastRemoteOperationAt(remoteData);
   return !localOperationAt || !remoteOperationAt || localOperationAt >= remoteOperationAt;
 };
 
+const hasRemoteOrderOperationFromDifferentClient = (localData = {}, remoteData = {}, operationType) => {
+  if (!hasOperationMarker(remoteData, operationType, getLastRemoteOperationType)) {
+    return false;
+  }
+
+  const remoteClientId = getLastClientId(remoteData);
+  return Boolean(remoteClientId) && remoteClientId !== getLastClientId(localData);
+};
+
 const shouldPreferRecentLocalOrder = (localData = {}, remoteData = {}, operationType) => {
   if (hasRecentLocalOperation(localData, remoteData, operationType)) {
     return true;
   }
 
+  if (hasRemoteOrderOperationFromDifferentClient(localData, remoteData, operationType)) {
+    return false;
+  }
+
   const localOperationAt = getLastLocalOperationAt(localData);
   const remoteOperationAt = getLastRemoteOperationAt(remoteData);
   return Boolean(localOperationAt) && (!remoteOperationAt || localOperationAt >= remoteOperationAt);