@tanstack/offline-transactions 0.1.2 → 1.0.0

package/src/executor/TransactionExecutor.ts

@@ -1,35 +1,12 @@
-import { createTraceState } from "@opentelemetry/api"
 import { DefaultRetryPolicy } from "../retry/RetryPolicy"
 import { NonRetriableError } from "../types"
 import { withNestedSpan } from "../telemetry/tracer"
-import type { SpanContext } from "@opentelemetry/api"
 import type { KeyScheduler } from "./KeyScheduler"
 import type { OutboxManager } from "../outbox/OutboxManager"
-import type {
-  OfflineConfig,
-  OfflineTransaction,
-  SerializedSpanContext,
-} from "../types"
+import type { OfflineConfig, OfflineTransaction } from "../types"
 
 const HANDLED_EXECUTION_ERROR = Symbol(`HandledExecutionError`)
 
-function toSpanContext(
-  serialized?: SerializedSpanContext
-): SpanContext | undefined {
-  if (!serialized) {
-    return undefined
-  }
-
-  return {
-    traceId: serialized.traceId,
-    spanId: serialized.spanId,
-    traceFlags: serialized.traceFlags,
-    traceState: serialized.traceState
-      ? createTraceState(serialized.traceState)
-      : undefined,
-  }
-}
-
 export class TransactionExecutor {
   private scheduler: KeyScheduler
   private outbox: OutboxManager
@@ -131,9 +108,6 @@ export class TransactionExecutor {
             ;(err as any)[HANDLED_EXECUTION_ERROR] = true
             throw err
           }
-        },
-        {
-          parentContext: toSpanContext(transaction.spanContext),
         }
       )
     } catch (error) {

package/src/outbox/OutboxManager.ts

@@ -10,7 +10,8 @@ export class OutboxManager {
 
   constructor(
     storage: StorageAdapter,
-    collections: Record<string, Collection>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    collections: Record<string, Collection<any, any, any, any, any>>
   ) {
     this.storage = storage
     this.serializer = new TransactionSerializer(collections)

package/src/outbox/TransactionSerializer.ts

@@ -7,10 +7,14 @@ import type {
 import type { Collection, PendingMutation } from "@tanstack/db"
 
 export class TransactionSerializer {
-  private collections: Record<string, Collection>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private collections: Record<string, Collection<any, any, any, any, any>>
   private collectionIdToKey: Map<string, string>
 
-  constructor(collections: Record<string, Collection>) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(
+    collections: Record<string, Collection<any, any, any, any, any>>
+  ) {
     this.collections = collections
     // Create reverse lookup from collection.id to registry key
     this.collectionIdToKey = new Map()

package/src/telemetry/tracer.ts

@@ -1,28 +1,23 @@
-import { SpanStatusCode, context, trace } from "@opentelemetry/api"
-import type { Span, SpanContext } from "@opentelemetry/api"
-
-const TRACER = trace.getTracer(`@tanstack/offline-transactions`, `0.0.1`)
-
 export interface SpanAttrs {
   [key: string]: string | number | boolean | undefined
 }
 
 interface WithSpanOptions {
-  parentContext?: SpanContext
+  parentContext?: any
 }
 
-function getParentContext(options?: WithSpanOptions) {
-  if (options?.parentContext) {
-    const parentSpan = trace.wrapSpanContext(options.parentContext)
-    return trace.setSpan(context.active(), parentSpan)
-  }
-
-  return context.active()
+// No-op span implementation
+const noopSpan = {
+  setAttribute: () => {},
+  setAttributes: () => {},
+  setStatus: () => {},
+  recordException: () => {},
+  end: () => {},
 }
 
 /**
  * Lightweight span wrapper with error handling.
- * Uses OpenTelemetry API which is no-op when tracing is disabled.
+ * No-op implementation - telemetry has been removed.
  *
  * By default, creates spans at the current context level (siblings).
  * Use withNestedSpan if you want parent-child relationships.
@@ -30,122 +25,42 @@ function getParentContext(options?: WithSpanOptions) {
 export async function withSpan<T>(
   name: string,
   attrs: SpanAttrs,
-  fn: (span: Span) => Promise<T>,
-  options?: WithSpanOptions
+  fn: (span: any) => Promise<T>,
+  _options?: WithSpanOptions
 ): Promise<T> {
-  const parentCtx = getParentContext(options)
-  const span = TRACER.startSpan(name, undefined, parentCtx)
-
-  // Filter out undefined attributes
-  const filteredAttrs: Record<string, string | number | boolean> = {}
-  for (const [key, value] of Object.entries(attrs)) {
-    if (value !== undefined) {
-      filteredAttrs[key] = value
-    }
-  }
-
-  span.setAttributes(filteredAttrs)
-
-  try {
-    const result = await fn(span)
-    span.setStatus({ code: SpanStatusCode.OK })
-    return result
-  } catch (error) {
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error instanceof Error ? error.message : String(error),
-    })
-    span.recordException(error as Error)
-    throw error
-  } finally {
-    span.end()
-  }
+  return await fn(noopSpan)
 }
 
 /**
  * Like withSpan but propagates context so child spans nest properly.
- * Use this when you want operations inside fn to be child spans.
+ * No-op implementation - telemetry has been removed.
  */
 export async function withNestedSpan<T>(
   name: string,
   attrs: SpanAttrs,
-  fn: (span: Span) => Promise<T>,
-  options?: WithSpanOptions
+  fn: (span: any) => Promise<T>,
+  _options?: WithSpanOptions
 ): Promise<T> {
-  const parentCtx = getParentContext(options)
-  const span = TRACER.startSpan(name, undefined, parentCtx)
-
-  // Filter out undefined attributes
-  const filteredAttrs: Record<string, string | number | boolean> = {}
-  for (const [key, value] of Object.entries(attrs)) {
-    if (value !== undefined) {
-      filteredAttrs[key] = value
-    }
-  }
-
-  span.setAttributes(filteredAttrs)
-
-  // Set the span as active context so child spans nest properly
-  const ctx = trace.setSpan(parentCtx, span)
-
-  try {
-    // Execute the function within the span's context
-    const result = await context.with(ctx, () => fn(span))
-    span.setStatus({ code: SpanStatusCode.OK })
-    return result
-  } catch (error) {
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error instanceof Error ? error.message : String(error),
-    })
-    span.recordException(error as Error)
-    throw error
-  } finally {
-    span.end()
-  }
+  return await fn(noopSpan)
 }
 
 /**
  * Creates a synchronous span for non-async operations
+ * No-op implementation - telemetry has been removed.
  */
 export function withSyncSpan<T>(
   name: string,
   attrs: SpanAttrs,
-  fn: (span: Span) => T,
-  options?: WithSpanOptions
+  fn: (span: any) => T,
+  _options?: WithSpanOptions
 ): T {
-  const parentCtx = getParentContext(options)
-  const span = TRACER.startSpan(name, undefined, parentCtx)
-
-  // Filter out undefined attributes
-  const filteredAttrs: Record<string, string | number | boolean> = {}
-  for (const [key, value] of Object.entries(attrs)) {
-    if (value !== undefined) {
-      filteredAttrs[key] = value
-    }
-  }
-
-  span.setAttributes(filteredAttrs)
-
-  try {
-    const result = fn(span)
-    span.setStatus({ code: SpanStatusCode.OK })
-    return result
-  } catch (error) {
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error instanceof Error ? error.message : String(error),
-    })
-    span.recordException(error as Error)
-    throw error
-  } finally {
-    span.end()
-  }
+  return fn(noopSpan)
 }
 
 /**
  * Get the current tracer instance
+ * No-op implementation - telemetry has been removed.
  */
 export function getTracer() {
-  return TRACER
+  return null
 }

package/src/types.ts

@@ -88,7 +88,8 @@ export interface StorageDiagnostic {
 }
 
 export interface OfflineConfig {
-  collections: Record<string, Collection>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  collections: Record<string, Collection<any, any, any, any, any>>
   mutationFns: Record<string, OfflineMutationFn>
   storage?: StorageAdapter
   maxConcurrency?: number