@livestore/livestore 0.0.55-dev.3 → 0.0.56-dev.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/livestore",
-  "version": "0.0.55-dev.3",
+  "version": "0.0.56-dev.0",
   "type": "module",
   "exports": {
     ".": {
@@ -30,9 +30,9 @@
   "dependencies": {
     "@graphql-typed-document-node/core": "^3.2.0",
     "@opentelemetry/api": "^1.9.0",
-    "@livestore/common": "0.0.55-dev.3",
-    "@livestore/utils": "0.0.55-dev.3",
-    "effect-db-schema": "0.0.55-dev.3"
+    "@livestore/utils": "0.0.56-dev.0",
+    "effect-db-schema": "0.0.56-dev.0",
+    "@livestore/common": "0.0.56-dev.0"
   },
   "devDependencies": {
     "@opentelemetry/sdk-trace-base": "1.25.1",
@@ -46,18 +46,14 @@
     "typescript": "5.5.4",
     "vite": "5.3.5",
     "vitest": "^2.0.4",
-    "@livestore/web": "0.0.55-dev.3"
+    "@livestore/web": "0.0.56-dev.0"
   },
   "peerDependencies": {
-    "@tauri-apps/api": "^1.4.0",
     "graphql": "16.x",
     "react": "^18",
     "react-dom": "^18"
   },
   "peerDependenciesMeta": {
-    "@tauri-apps/api": {
-      "optional": true
-    },
     "graphql": {
       "optional": true
     }

package/src/__tests__/react/fixture.tsx

@@ -5,7 +5,7 @@ import React from 'react'
 
 import { globalReactivityGraph } from '../../global-state.js'
 import type { LiveStoreContext } from '../../index.js'
-import { createStorePromise, DbSchema, makeReactivityGraph, makeSchema, ParseUtils, sql } from '../../index.js'
+import { createStorePromise, DbSchema, makeReactivityGraph, makeSchema, sql } from '../../index.js'
 import * as LiveStoreReact from '../../react/index.js'
 
 export type Todo = {
@@ -57,8 +57,6 @@ const AppRouterSchema = DbSchema.table(
 export const tables = { todos, app, userInfo, AppRouterSchema }
 export const schema = makeSchema({ tables })
 
-export const parseTodos = ParseUtils.many(todos)
-
 export const makeTodoMvc = async ({
   otelTracer,
   otelContext,

package/src/index.ts

@@ -22,7 +22,7 @@ export type {
   Effect,
 } from './reactive.js'
 export { LiveStoreJSQuery, computed } from './reactiveQueries/js.js'
-export { LiveStoreSQLQuery, querySQL, type MapRows } from './reactiveQueries/sql.js'
+export { LiveStoreSQLQuery, querySQL } from './reactiveQueries/sql.js'
 export { LiveStoreGraphQLQuery, queryGraphQL } from './reactiveQueries/graphql.js'
 export {
   type GetAtomResult,

package/src/react/LiveStoreProvider.test.tsx

@@ -1,11 +1,12 @@
 import type { BootDb } from '@livestore/common'
 import { sql } from '@livestore/common'
+import { Schema } from '@livestore/utils/effect'
 import { makeInMemoryAdapter } from '@livestore/web'
 import { render, screen, waitFor, waitForElementToBeRemoved } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
-import { parseTodos, schema } from '../__tests__/react/fixture.js'
+import { schema, tables } from '../__tests__/react/fixture.js'
 import { querySQL } from '../reactiveQueries/sql.js'
 import * as LiveStoreReact from './index.js'
 import { LiveStoreProvider } from './LiveStoreProvider.js'
@@ -14,7 +15,7 @@ describe('LiveStoreProvider', () => {
   it('simple', async () => {
     let appRenderCount = 0
 
-    const allTodos$ = querySQL(`select * from todos`, { map: parseTodos })
+    const allTodos$ = querySQL(`select * from todos`, { schema: Schema.Array(tables.todos.schema) })
 
     const App = () => {
       appRenderCount++

package/src/react/LiveStoreProvider.tsx

@@ -21,14 +21,23 @@ interface LiveStoreProviderProps<GraphQLContext> {
   graphQLOptions?: GraphQLOptions<GraphQLContext>
   otelOptions?: OtelOptions
   renderLoading: (status: BootStatus) => ReactElement
+  renderError?: (error: UnexpectedError | unknown) => ReactElement
+  renderShutdown?: () => ReactElement
   adapter: StoreAdapterFactory
   batchUpdates?: (run: () => void) => void
   disableDevtools?: boolean
   signal?: AbortSignal
 }
 
+const defaultRenderError = (error: UnexpectedError | unknown) => (
+  <>{Schema.is(UnexpectedError)(error) ? error.toString() : errorToString(error)}</>
+)
+const defaultRenderShutdown = () => <>LiveStore Shutdown</>
+
 export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
   renderLoading,
+  renderError = defaultRenderError,
+  renderShutdown = defaultRenderShutdown,
   graphQLOptions,
   otelOptions,
   children,
@@ -51,19 +60,15 @@ export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
   })
 
   if (storeCtx.stage === 'error') {
-    return (
-      <div>
-        {Schema.is(UnexpectedError)(storeCtx.error) ? storeCtx.error.toString() : errorToString(storeCtx.error)}
-      </div>
-    )
+    return renderError(storeCtx.error)
   }
 
   if (storeCtx.stage === 'shutdown') {
-    return <div>LiveStore Shutdown</div>
+    return renderShutdown()
   }
 
   if (storeCtx.stage !== 'running') {
-    return <div>{renderLoading(storeCtx)}</div>
+    return renderLoading(storeCtx)
   }
 
   window.__debugLiveStore = storeCtx.store
@@ -71,6 +76,18 @@ export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
   return <LiveStoreContext.Provider value={storeCtx}>{children}</LiveStoreContext.Provider>
 }
 
+type SchemaKey = string
+const semaphoreMap = new Map<SchemaKey, Effect.Semaphore>()
+
+const withSemaphore = (schemaKey: SchemaKey) => {
+  let semaphore = semaphoreMap.get(schemaKey)
+  if (!semaphore) {
+    semaphore = Effect.makeSemaphore(1).pipe(Effect.runSync)
+    semaphoreMap.set(schemaKey, semaphore)
+  }
+  return semaphore.withPermits(1)
+}
+
 const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
   schema,
   graphQLOptions,
@@ -195,6 +212,10 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
       )
     }).pipe(
       Effect.scoped,
+      // NOTE we're running the code above in a semaphore to make sure a previous store is always fully
+      // shutdown before a new one is created - especially when shutdown logic is async. You can't trust `React.useEffect`.
+      // Thank you to Mattia Manzati for this idea.
+      withSemaphore(schema.key),
       Effect.tapCauseLogPretty,
       Effect.annotateLogs({ thread: 'window' }),
       Effect.provide(Logger.pretty),

package/src/react/useQuery.test.tsx

@@ -1,8 +1,9 @@
+import { Schema } from '@livestore/utils/effect'
 import { renderHook } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
-import { makeTodoMvc, parseTodos, todos } from '../__tests__/react/fixture.js'
+import { makeTodoMvc, tables, todos } from '../__tests__/react/fixture.js'
 import { querySQL } from '../reactiveQueries/sql.js'
 import * as LiveStoreReact from './index.js'
 
@@ -12,7 +13,7 @@ describe('useQuery', () => {
 
     const renderCount = makeRenderCount()
 
-    const allTodos$ = querySQL(`select * from todos`, { map: parseTodos })
+    const allTodos$ = querySQL(`select * from todos`, { schema: Schema.Array(tables.todos.schema) })
 
     const { result } = renderHook(
       () => {
@@ -38,8 +39,14 @@ describe('useQuery', () => {
 
     const renderCount = makeRenderCount()
 
-    const todo1$ = querySQL(`select * from todos where id = 't1'`, { label: 'libraryTracksView1', map: parseTodos })
-    const todo2$ = querySQL(`select * from todos where id = 't2'`, { label: 'libraryTracksView2', map: parseTodos })
+    const todo1$ = querySQL(`select * from todos where id = 't1'`, {
+      label: 'libraryTracksView1',
+      schema: Schema.Array(tables.todos.schema),
+    })
+    const todo2$ = querySQL(`select * from todos where id = 't2'`, {
+      label: 'libraryTracksView2',
+      schema: Schema.Array(tables.todos.schema),
+    })
 
     store.mutate(
       todos.insert({ id: 't1', text: 'buy milk', completed: false }),

package/src/react/useRow.test.tsx

@@ -1,12 +1,11 @@
-import { ReadonlyRecord } from '@livestore/utils/effect'
+import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
 import { render, renderHook } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
-import type { Todo } from '../__tests__/react/fixture.js'
-import { makeTodoMvc, todos } from '../__tests__/react/fixture.js'
+import { makeTodoMvc, tables, todos } from '../__tests__/react/fixture.js'
 import { getSimplifiedRootSpan } from '../__tests__/react/utils/otel.js'
 import * as LiveStore from '../index.js'
 import * as LiveStoreReact from './index.js'
@@ -118,7 +117,11 @@ describe.concurrent('useRow', () => {
     using inputs = await makeTodoMvc({ useGlobalReactivityGraph: false })
     const { wrapper, store, reactivityGraph, makeRenderCount, AppRouterSchema } = inputs
 
-    const allTodos$ = LiveStore.querySQL<Todo[]>(`select * from todos`, { label: 'allTodos', reactivityGraph })
+    const allTodos$ = LiveStore.querySQL(`select * from todos`, {
+      label: 'allTodos',
+      schema: Schema.Array(tables.todos.schema),
+      reactivityGraph,
+    })
 
     const appRouterRenderCount = makeRenderCount()
     let globalSetState: LiveStoreReact.StateSetters<typeof AppRouterSchema> | undefined
@@ -176,7 +179,7 @@ describe.concurrent('useRow', () => {
 
     expect(appRouterRenderCount.val).toBe(2)
     expect(renderResult.getByRole('content').innerHTML).toMatchInlineSnapshot(
-      `"{"id":"t1","text":"buy milk","completed":false}"`,
+      `"{"completed":false,"id":"t1","text":"buy milk"}"`,
     )
 
     expect(renderResult.getByRole('current-id').innerHTML).toMatchInlineSnapshot('"Current Task Id: t1"')
@@ -214,10 +217,11 @@ describe.concurrent('useRow', () => {
         const [_row, _setRow, rowState$] = LiveStoreReact.useRow(AppComponentSchema, userId, { reactivityGraph })
         const todos = LiveStoreReact.useTemporaryQuery(
           () =>
-            LiveStore.querySQL<any[]>(
-              (get) => LiveStore.sql`select * from todos where text like '%${get(rowState$).text}%'`,
-              { reactivityGraph, label: 'todosFiltered' },
-            ),
+            LiveStore.querySQL((get) => LiveStore.sql`select * from todos where text like '%${get(rowState$).text}%'`, {
+              schema: Schema.Array(tables.todos.schema),
+              reactivityGraph,
+              label: 'todosFiltered',
+            }),
           userId,
         )
 

package/src/react/useTemporaryQuery.test.tsx

@@ -1,7 +1,8 @@
+import { Schema } from '@livestore/utils/effect'
 import { renderHook } from '@testing-library/react'
 import { describe, expect, it } from 'vitest'
 
-import { makeTodoMvc, parseTodos, todos } from '../__tests__/react/fixture.js'
+import { makeTodoMvc, tables, todos } from '../__tests__/react/fixture.js'
 import type * as LiveStore from '../index.js'
 import { querySQL } from '../reactiveQueries/sql.js'
 import * as LiveStoreReact from './index.js'
@@ -24,7 +25,9 @@ describe('useTemporaryQuery', () => {
         renderCount.inc()
 
         return LiveStoreReact.useTemporaryQuery(() => {
-          const query$ = querySQL(`select * from todos where id = '${id}'`, { map: parseTodos })
+          const query$ = querySQL(`select * from todos where id = '${id}'`, {
+            schema: Schema.Array(tables.todos.schema),
+          })
           queryMap.set(id, query$)
           return query$
         }, id)

package/src/reactiveQueries/graphql.ts

@@ -25,7 +25,11 @@ export const queryGraphQL = <
     label,
     reactivityGraph,
     map,
-  }: { label?: string; reactivityGraph?: ReactivityGraph; map?: MapResult<TResultMapped, TResult> } = {},
+  }: {
+    label?: string
+    reactivityGraph?: ReactivityGraph
+    map?: MapResult<TResultMapped, TResult>
+  } = {},
 ): LiveQuery<TResultMapped, QueryInfoNone> =>
   new LiveStoreGraphQLQuery({ document, genVariableValues, label, reactivityGraph, map })
 

package/src/reactiveQueries/sql.test.ts

@@ -1,10 +1,11 @@
+import { Schema } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
 import { describe, expect, it } from 'vitest'
 
-import { makeTodoMvc, todos } from '../__tests__/react/fixture.js'
+import { makeTodoMvc, tables } from '../__tests__/react/fixture.js'
 import { getSimplifiedRootSpan } from '../__tests__/react/utils/otel.js'
-import { computed, ParseUtils, querySQL, rawSqlMutation, sql } from '../index.js'
+import { computed, querySQL, rawSqlMutation, sql } from '../index.js'
 
 /*
 TODO write tests for:
@@ -45,7 +46,10 @@ describe('otel', () => {
     using inputs = await makeQuery()
     const { store, exporter, span } = inputs
 
-    const query = querySQL(`select * from todos`, { queriedTables: new Set(['todos']) })
+    const query = querySQL(`select * from todos`, {
+      schema: Schema.Array(tables.todos.schema),
+      queriedTables: new Set(['todos']),
+    })
     expect(query.run()).toMatchInlineSnapshot('[]')
 
     store.mutate(rawSqlMutation({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
@@ -53,7 +57,7 @@ describe('otel', () => {
     expect(query.run()).toMatchInlineSnapshot(`
       [
         {
-          "completed": 0,
+          "completed": false,
           "id": "t1",
           "text": "buy milk",
         },
@@ -172,7 +176,7 @@ describe('otel', () => {
     const filter = computed(() => `where completed = 0`, { label: 'where-filter' })
     const query = querySQL((get) => `select * from todos ${get(filter)}`, {
       label: 'all todos',
-      map: ParseUtils.first(todos, defaultTodo),
+      schema: Schema.Array(tables.todos.schema).pipe(Schema.headOrElse(() => defaultTodo)),
     })
 
     expect(query.run()).toMatchInlineSnapshot(`

package/src/reactiveQueries/sql.ts

@@ -1,26 +1,24 @@
 import { type Bindable, prepareBindValues, type QueryInfo, type QueryInfoNone } from '@livestore/common'
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, TreeFormatter } from '@livestore/utils/effect'
+import { Schema, SchemaEquivalence, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import { globalReactivityGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
+import { NOT_REFRESHED_YET } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
 import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
 import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 
-export type MapRows<TResult, TRaw = any> =
-  | ((rows: ReadonlyArray<TRaw>) => TResult)
-  | Schema.Schema<TResult, ReadonlyArray<TRaw>, unknown>
-
 /**
  * NOTE `querySQL` is only supposed to read data. Don't use it to insert/update/delete data but use mutations instead.
  */
-export const querySQL = <TResult, TRaw = any>(
+export const querySQL = <TResultSchema, TResult = TResultSchema>(
   query: string | ((get: GetAtomResult) => string),
-  options?: {
-    map?: MapRows<TResult, TRaw>
+  options: {
+    schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
+    map?: (rows: TResultSchema) => TResult
     /**
      * Can be provided explicitly to slightly speed up initial query performance
      *
@@ -32,21 +30,23 @@ export const querySQL = <TResult, TRaw = any>(
     reactivityGraph?: ReactivityGraph
   },
 ): LiveQuery<TResult, QueryInfoNone> =>
-  new LiveStoreSQLQuery<TResult, QueryInfoNone>({
+  new LiveStoreSQLQuery<TResultSchema, TResult, QueryInfoNone>({
     label: options?.label,
     genQueryString: query,
     queriedTables: options?.queriedTables,
     bindValues: options?.bindValues,
     reactivityGraph: options?.reactivityGraph,
     map: options?.map,
+    schema: options.schema,
     queryInfo: { _tag: 'None' },
   })
 
 /* An object encapsulating a reactive SQL query */
-export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoNone> extends LiveStoreQueryBase<
-  TResult,
-  TQueryInfo
-> {
+export class LiveStoreSQLQuery<
+  TResultSchema,
+  TResult = TResultSchema,
+  TQueryInfo extends QueryInfo = QueryInfoNone,
+> extends LiveStoreQueryBase<TResult, TQueryInfo> {
   _tag: 'sql' = 'sql'
 
   /** A reactive thunk representing the query text */
@@ -62,7 +62,8 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
   /** Currently only used by `rowQuery` for lazy table migrations and eager default row insertion */
   private execBeforeFirstRun
 
-  private mapRows
+  private mapResult: (rows: TResultSchema) => TResult
+  private schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
 
   queryInfo: TQueryInfo
 
@@ -70,8 +71,9 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
     genQueryString,
     queriedTables,
     bindValues,
-    label: label_,
+    label = genQueryString.toString(),
     reactivityGraph,
+    schema,
     map,
     execBeforeFirstRun,
     queryInfo,
@@ -81,51 +83,20 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
     queriedTables?: Set<string>
     bindValues?: Bindable
     reactivityGraph?: ReactivityGraph
-    map?: MapRows<TResult>
+    schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
+    map?: (rows: TResultSchema) => TResult
     execBeforeFirstRun?: (ctx: QueryContext) => void
     queryInfo?: TQueryInfo
   }) {
     super()
 
-    const label = label_ ?? genQueryString.toString()
     this.label = `sql(${label})`
     this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
     this.execBeforeFirstRun = execBeforeFirstRun
     this.queryInfo = queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
-    this.mapRows =
-      map === undefined
-        ? (rows: any) => rows as TResult
-        : Schema.isSchema(map)
-          ? (rows: any, opts: { sqlString: string }) => {
-              const parseResult = Schema.decodeEither(map as Schema.Schema<TResult, ReadonlyArray<any>>)(rows)
-              if (parseResult._tag === 'Left') {
-                const parseErrorStr = TreeFormatter.formatErrorSync(parseResult.left)
-                const expectedSchemaStr = String(map.ast)
-                const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
-
-                console.error(
-                  `\
-Error parsing SQL query result.
-
-Query: ${opts.sqlString}\
-${bindValuesStr}
-
-Expected schema: ${expectedSchemaStr}
 
-Error: ${parseErrorStr}
-
-Result:`,
-                  rows,
-                )
-                // console.error(`Error parsing SQL query result: ${TreeFormatter.formatErrorSync(parseResult.left)}`)
-                return shouldNeverHappen(`Error parsing SQL query result: ${parseResult.left}`)
-              } else {
-                return parseResult.right as TResult
-              }
-            }
-          : typeof map === 'function'
-            ? map
-            : shouldNeverHappen(`Invalid map function ${map}`)
+    this.schema = schema
+    this.mapResult = map === undefined ? (rows: any) => rows as TResult : map
 
     let queryString$OrQueryString: string | Thunk<string, QueryContext, RefreshReason>
     if (typeof genQueryString === 'function') {
@@ -137,7 +108,11 @@ Result:`,
           setDebugInfo({ _tag: 'js', label: `${label}:queryString`, query: queryString, durationMs })
           return queryString
         },
-        { label: `${label}:queryString`, meta: { liveStoreThunkType: 'sqlQueryString' } },
+        {
+          label: `${label}:queryString`,
+          meta: { liveStoreThunkType: 'sqlQueryString' },
+          equal: (a, b) => a === b,
+        },
       )
 
       this.queryString$ = queryString$OrQueryString
@@ -149,6 +124,15 @@ Result:`,
 
     const queriedTablesRef = { current: queriedTables }
 
+    const schemaEqual = SchemaEquivalence.make(schema)
+    // TODO also support derived equality for `map` (probably will depend on having an easy way to transform a schema without an `encode` step)
+    // This would mean dropping the `map` option
+    const equal =
+      map === undefined
+        ? (a: TResult, b: TResult) =>
+            a === NOT_REFRESHED_YET || b === NOT_REFRESHED_YET ? false : schemaEqual(a as any, b as any)
+        : undefined
+
     const results$ = this.reactivityGraph.makeThunk<TResult>(
       (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) =>
         otelTracer.startActiveSpan(
@@ -189,7 +173,31 @@ Result:`,
 
             span.setAttribute('sql.rowsCount', rawResults.length)
 
-            const result = this.mapRows(rawResults, { sqlString })
+            const parsedResult = Schema.decodeEither(this.schema)(rawResults)
+
+            if (parsedResult._tag === 'Left') {
+              const parseErrorStr = TreeFormatter.formatErrorSync(parsedResult.left)
+              const expectedSchemaStr = String(this.schema.ast)
+              const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
+
+              console.error(
+                `\
+Error parsing SQL query result.
+
+Query: ${sqlString}\
+${bindValuesStr}
+
+Expected schema: ${expectedSchemaStr}
+
+Error: ${parseErrorStr}
+
+Result:`,
+                rawResults,
+              )
+              return shouldNeverHappen(`Error parsing SQL query result: ${parsedResult.left}`)
+            }
+
+            const result = this.mapResult(parsedResult.right)
 
             span.end()
 
@@ -202,45 +210,12 @@ Result:`,
             return result
           },
         ),
-      { label: queryLabel },
+      { label: queryLabel, equal },
     )
 
     this.results$ = results$
   }
 
-  /**
-   * Returns a new reactive query that contains the result of
-   * running an arbitrary JS computation on the results of this SQL query.
-   */
-  // pipe = <U>(fn: (result: Result, get: GetAtomResult) => U): LiveStoreJSQuery<U> =>
-  //   new LiveStoreJSQuery({
-  //     fn: (get) => {
-  //       const results = get(this.results$!)
-  //       return fn(results, get)
-  //     },
-  //     label: `${this.label}:js`,
-  //     onDestroy: () => this.destroy(),
-  //     reactivityGraph: this.reactivityGraph,
-  //     queryInfo: undefined,
-  //   })
-
-  /** Returns a reactive query  */
-  // getFirstRow = (args?: { defaultValue?: Result }) =>
-  //   new LiveStoreJSQuery({
-  //     fn: (get) => {
-  //       const results = get(this.results$!)
-  //       if (results.length === 0 && args?.defaultValue === undefined) {
-  //         // const queryLabel = this._tag === 'sql' ? this.queryString$!.computeResult(otelContext) : this.label
-  //         const queryLabel = this.label
-  //         return shouldNeverHappen(`Expected query ${queryLabel} to return at least one result`)
-  //       }
-  //       return results[0] ?? args!.defaultValue!
-  //     },
-  //     label: `${this.label}:first`,
-  //     onDestroy: () => this.destroy(),
-  //     reactivityGraph: this.reactivityGraph,
-  //   })
-
   destroy = () => {
     if (this.queryString$ !== undefined) {
       this.reactivityGraph.destroyNode(this.queryString$)