@tanstack/db 0.0.1

package/dist/esm/types.d.ts

@@ -0,0 +1,94 @@
+import { Collection } from './collection.js';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Transaction } from './transactions.js';
+export type TransactionState = `pending` | `persisting` | `completed` | `failed`;
+/**
+ * Represents a pending mutation within a transaction
+ * Contains information about the original and modified data, as well as metadata
+ */
+export interface PendingMutation<T extends object = Record<string, unknown>> {
+    mutationId: string;
+    original: Record<string, unknown>;
+    modified: Record<string, unknown>;
+    changes: Record<string, unknown>;
+    key: string;
+    type: OperationType;
+    metadata: unknown;
+    syncMetadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+    collection: Collection<T>;
+}
+/**
+ * Configuration options for creating a new transaction
+ */
+export type MutationFnParams = {
+    transaction: Transaction;
+};
+export type MutationFn = (params: MutationFnParams) => Promise<any>;
+export interface TransactionConfig {
+    /** Unique identifier for the transaction */
+    id?: string;
+    autoCommit?: boolean;
+    mutationFn: MutationFn;
+    /** Custom metadata to associate with the transaction */
+    metadata?: Record<string, unknown>;
+}
+export type { Transaction };
+type Value<TExtensions = never> = string | number | boolean | bigint | null | TExtensions | Array<Value<TExtensions>> | {
+    [key: string]: Value<TExtensions>;
+};
+export type Row<TExtensions = never> = Record<string, Value<TExtensions>>;
+export type OperationType = `insert` | `update` | `delete`;
+export interface SyncConfig<T extends object = Record<string, unknown>> {
+    sync: (params: {
+        collection: Collection<T>;
+        begin: () => void;
+        write: (message: ChangeMessage<T>) => void;
+        commit: () => void;
+    }) => void;
+    /**
+     * Get the sync metadata for insert operations
+     * @returns Record containing primaryKey and relation information
+     */
+    getSyncMetadata?: () => Record<string, unknown>;
+}
+export interface ChangeMessage<T extends object = Record<string, unknown>> {
+    key: string;
+    value: T;
+    previousValue?: T;
+    type: OperationType;
+    metadata?: Record<string, unknown>;
+}
+export interface OptimisticChangeMessage<T extends object = Record<string, unknown>> extends ChangeMessage<T> {
+    isActive?: boolean;
+}
+/**
+ * The Standard Schema interface.
+ * This follows the standard-schema specification: https://github.com/standard-schema/standard-schema
+ */
+export type StandardSchema<T> = StandardSchemaV1 & {
+    "~standard": {
+        types?: {
+            input: T;
+            output: T;
+        };
+    };
+};
+/**
+ * Type alias for StandardSchema
+ */
+export type StandardSchemaAlias<T = unknown> = StandardSchema<T>;
+export interface OperationConfig {
+    metadata?: Record<string, unknown>;
+}
+export interface InsertConfig {
+    key?: string | Array<string | undefined>;
+    metadata?: Record<string, unknown>;
+}
+export interface CollectionConfig<T extends object = Record<string, unknown>> {
+    id: string;
+    sync: SyncConfig<T>;
+    schema?: StandardSchema<T>;
+}
+export type ChangesPayload<T extends object = Record<string, unknown>> = Array<ChangeMessage<T>>;

package/dist/esm/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function getLockedObjects(): Set<string>;
+export declare function getGlobalVersion(): number;
+export declare function advanceGlobalVersion(): number;

package/dist/esm/utils.js

@@ -0,0 +1,17 @@
+function getLockedObjects() {
+  return /* @__PURE__ */ new Set();
+}
+let globalVersion = 0;
+function getGlobalVersion() {
+  return globalVersion;
+}
+function advanceGlobalVersion() {
+  console.log(`==== advancing global version`, globalVersion + 1);
+  return globalVersion++;
+}
+export {
+  advanceGlobalVersion,
+  getGlobalVersion,
+  getLockedObjects
+};
+//# sourceMappingURL=utils.js.map

package/dist/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["export function getLockedObjects(): Set<string> {\n  // Stub implementation that returns an empty Set\n  return new Set()\n}\n\nlet globalVersion = 0\n\nexport function getGlobalVersion(): number {\n  return globalVersion\n}\n\nexport function advanceGlobalVersion(): number {\n  console.log(`==== advancing global version`, globalVersion + 1)\n  return globalVersion++\n}\n"],"names":[],"mappings":"AAAO,SAAS,mBAAgC;AAE9C,6BAAW,IAAI;AACjB;AAEA,IAAI,gBAAgB;AAEb,SAAS,mBAA2B;AAClC,SAAA;AACT;AAEO,SAAS,uBAA+B;AACrC,UAAA,IAAI,iCAAiC,gBAAgB,CAAC;AACvD,SAAA;AACT;"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@tanstack/db",
+  "description": "A reactive client store for building super fast apps on sync",
+  "version": "0.0.1",
+  "dependencies": {
+    "@electric-sql/d2ts": "^0.1.5",
+    "@standard-schema/spec": "^1.0.0",
+    "@tanstack/store": "^0.7.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-istanbul": "^3.0.9"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "packageManager": "pnpm@10.5.2",
+  "peerDependencies": {
+    "typescript": ">=4.7"
+  },
+  "author": "Kyle Mathews",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TanStack/db.git",
+    "directory": "packages/db"
+  },
+  "homepage": "https://tanstack.com/optimistic",
+  "keywords": [
+    "optimistic",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "eslint . --fix",
+    "test": "npx vitest --run"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "types": "dist/esm/index.d.ts"
+}

package/src/SortedMap.ts

@@ -0,0 +1,163 @@
+/**
+ * A Map implementation that keeps its entries sorted based on a comparator function
+ * @template TKey - The type of keys in the map
+ * @template TValue - The type of values in the map
+ */
+export class SortedMap<TKey, TValue> {
+  private map: Map<TKey, TValue>
+  private sortedKeys: Array<TKey>
+  private comparator: (a: TValue, b: TValue) => number
+
+  /**
+   * Creates a new SortedMap instance
+   *
+   * @param comparator - Optional function to compare values for sorting
+   */
+  constructor(comparator?: (a: TValue, b: TValue) => number) {
+    this.map = new Map<TKey, TValue>()
+    this.sortedKeys = []
+    this.comparator = comparator || this.defaultComparator
+  }
+
+  /**
+   * Default comparator function used when none is provided
+   *
+   * @param a - First value to compare
+   * @param b - Second value to compare
+   * @returns -1 if a < b, 1 if a > b, 0 if equal
+   */
+  private defaultComparator(a: TValue, b: TValue): number {
+    if (a < b) return -1
+    if (a > b) return 1
+    return 0
+  }
+
+  /**
+   * Sets a key-value pair in the map and maintains sort order
+   *
+   * @param key - The key to set
+   * @param value - The value to associate with the key
+   * @returns This SortedMap instance for chaining
+   */
+  set(key: TKey, value: TValue): this {
+    this.map.set(key, value)
+
+    if (!this.sortedKeys.includes(key)) {
+      this.sortedKeys.push(key)
+    }
+
+    // Re-sort keys based on values
+    this.sortedKeys.sort((a, b) => {
+      const valueA = this.map.get(a)!
+      const valueB = this.map.get(b)!
+      return this.comparator(valueA, valueB)
+    })
+
+    return this
+  }
+
+  /**
+   * Gets a value by its key
+   *
+   * @param key - The key to look up
+   * @returns The value associated with the key, or undefined if not found
+   */
+  get(key: TKey): TValue | undefined {
+    return this.map.get(key)
+  }
+
+  /**
+   * Removes a key-value pair from the map
+   *
+   * @param key - The key to remove
+   * @returns True if the key was found and removed, false otherwise
+   */
+  delete(key: TKey): boolean {
+    if (this.map.delete(key)) {
+      const index = this.sortedKeys.indexOf(key)
+      this.sortedKeys.splice(index, 1)
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Checks if a key exists in the map
+   *
+   * @param key - The key to check
+   * @returns True if the key exists, false otherwise
+   */
+  has(key: TKey): boolean {
+    return this.map.has(key)
+  }
+
+  /**
+   * Removes all key-value pairs from the map
+   */
+  clear(): void {
+    this.map.clear()
+    this.sortedKeys = []
+  }
+
+  /**
+   * Gets the number of key-value pairs in the map
+   */
+  get size(): number {
+    return this.map.size
+  }
+
+  /**
+   * Default iterator that returns entries in sorted order
+   *
+   * @returns An iterator for the map's entries
+   */
+  *[Symbol.iterator](): IterableIterator<[TKey, TValue]> {
+    for (const key of this.sortedKeys) {
+      yield [key, this.map.get(key)!] as [TKey, TValue]
+    }
+  }
+
+  /**
+   * Returns an iterator for the map's entries in sorted order
+   *
+   * @returns An iterator for the map's entries
+   */
+  entries(): IterableIterator<[TKey, TValue]> {
+    return this[Symbol.iterator]()
+  }
+
+  /**
+   * Returns an iterator for the map's keys in sorted order
+   *
+   * @returns An iterator for the map's keys
+   */
+  keys(): IterableIterator<TKey> {
+    return this.sortedKeys[Symbol.iterator]()
+  }
+
+  /**
+   * Returns an iterator for the map's values in sorted order
+   *
+   * @returns An iterator for the map's values
+   */
+  values(): IterableIterator<TValue> {
+    return function* (this: SortedMap<TKey, TValue>) {
+      for (const key of this.sortedKeys) {
+        yield this.map.get(key)!
+      }
+    }.call(this)
+  }
+
+  /**
+   * Executes a callback function for each key-value pair in the map in sorted order
+   *
+   * @param callbackfn - Function to execute for each entry
+   */
+  forEach(
+    callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void
+  ): void {
+    for (const key of this.sortedKeys) {
+      callbackfn(this.map.get(key)!, key, this.map)
+    }
+  }
+}