@livestore/livestore 0.3.0-dev.5 → 0.3.0-dev.50

package/src/live-queries/graphql.ts

@@ -1,219 +0,0 @@
-import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core'
-import type { QueryInfo } from '@livestore/common'
-import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, TreeFormatter } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
-import * as graphql from 'graphql'
-
-import { globalReactivityGraph } from '../global-state.js'
-import { isThunk, type Thunk } from '../reactive.js'
-import type { Store } from '../store/store.js'
-import type { BaseGraphQLContext, RefreshReason } from '../store/store-types.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 MapResult<To, From> = ((res: From, get: GetAtomResult) => To) | Schema.Schema<To, From>
-
-export const queryGraphQL = <
-  TResult extends Record<string, any>,
-  TVariableValues extends Record<string, any>,
-  TResultMapped extends Record<string, any> = TResult,
->(
-  document: DocumentNode<TResult, TVariableValues>,
-  genVariableValues: TVariableValues | ((get: GetAtomResult) => TVariableValues),
-  {
-    label,
-    reactivityGraph,
-    map,
-  }: {
-    label?: string
-    reactivityGraph?: ReactivityGraph
-    map?: MapResult<TResultMapped, TResult>
-  } = {},
-): LiveQuery<TResultMapped, QueryInfo.None> =>
-  new LiveStoreGraphQLQuery({ document, genVariableValues, label, reactivityGraph, map })
-
-export class LiveStoreGraphQLQuery<
-  TResult extends Record<string, any>,
-  TVariableValues extends Record<string, any>,
-  TContext extends BaseGraphQLContext,
-  TResultMapped extends Record<string, any> = TResult,
-> extends LiveStoreQueryBase<TResultMapped, QueryInfo.None> {
-  _tag: 'graphql' = 'graphql'
-
-  /** The abstract GraphQL query */
-  document: DocumentNode<TResult, TVariableValues>
-
-  /** A reactive thunk representing the query results */
-  results$: Thunk<TResultMapped, QueryContext, RefreshReason>
-
-  variableValues$: Thunk<TVariableValues, QueryContext, RefreshReason> | undefined
-
-  label: string
-
-  protected reactivityGraph: ReactivityGraph
-
-  queryInfo: QueryInfo.None = { _tag: 'None' }
-
-  private mapResult
-
-  constructor({
-    document,
-    label,
-    genVariableValues,
-    reactivityGraph,
-    map,
-  }: {
-    document: DocumentNode<TResult, TVariableValues>
-    genVariableValues: TVariableValues | ((get: GetAtomResult) => TVariableValues)
-    label?: string
-    reactivityGraph?: ReactivityGraph
-    map?: MapResult<TResultMapped, TResult>
-  }) {
-    super()
-
-    const labelWithDefault = label ?? graphql.getOperationAST(document)?.name?.value ?? 'graphql'
-
-    this.label = labelWithDefault
-    this.document = document
-
-    this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
-
-    this.mapResult =
-      map === undefined
-        ? (res: TResult) => res as any as TResultMapped
-        : Schema.isSchema(map)
-          ? (res: TResult) => {
-              const parseResult = Schema.decodeEither(map as Schema.Schema<TResultMapped, TResult>)(res)
-              if (parseResult._tag === 'Left') {
-                console.error(`Error parsing GraphQL query result: ${TreeFormatter.formatErrorSync(parseResult.left)}`)
-                return shouldNeverHappen(`Error parsing SQL query result: ${parseResult.left}`)
-              } else {
-                return parseResult.right as TResultMapped
-              }
-            }
-          : typeof map === 'function'
-            ? map
-            : shouldNeverHappen(`Invalid map function ${map}`)
-
-    // TODO don't even create a thunk if variables are static
-    let variableValues$OrvariableValues
-
-    if (typeof genVariableValues === 'function') {
-      variableValues$OrvariableValues = this.reactivityGraph.makeThunk(
-        (get, _setDebugInfo, { rootOtelContext }, otelContext) => {
-          return genVariableValues(makeGetAtomResult(get, otelContext ?? rootOtelContext))
-        },
-        { label: `${labelWithDefault}:variableValues`, meta: { liveStoreThunkType: 'graphql.variables' } },
-      )
-      this.variableValues$ = variableValues$OrvariableValues
-    } else {
-      variableValues$OrvariableValues = genVariableValues
-    }
-
-    const resultsLabel = `${labelWithDefault}:results`
-    this.results$ = this.reactivityGraph.makeThunk<TResultMapped>(
-      (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) => {
-        const variableValues = isThunk(variableValues$OrvariableValues)
-          ? (get(variableValues$OrvariableValues) as TVariableValues)
-          : (variableValues$OrvariableValues as TVariableValues)
-        const { result, queriedTables, durationMs } = this.queryOnce({
-          document,
-          variableValues,
-          otelContext: otelContext ?? rootOtelContext,
-          otelTracer,
-          store: store as Store<TContext>,
-          get: makeGetAtomResult(get, otelContext ?? rootOtelContext),
-        })
-
-        // Add dependencies on any tables that were used
-        for (const tableName of queriedTables) {
-          const tableRef = store.tableRefs[tableName] ?? shouldNeverHappen(`No table ref found for ${tableName}`)
-          get(tableRef)
-        }
-
-        setDebugInfo({ _tag: 'graphql', label: resultsLabel, query: graphql.print(document), durationMs })
-
-        return result
-      },
-      { label: resultsLabel, meta: { liveStoreThunkType: 'graphql.result' } },
-      // otelContext,
-    )
-  }
-
-  queryOnce = ({
-    document,
-    otelContext,
-    otelTracer,
-    variableValues,
-    store,
-    get,
-  }: {
-    document: graphql.DocumentNode
-    otelContext: otel.Context
-    otelTracer: otel.Tracer
-    variableValues: TVariableValues
-    store: Store<TContext>
-    get: GetAtomResult
-  }) => {
-    const schema =
-      store.graphQLSchema ?? shouldNeverHappen("Can't run a GraphQL query on a store without GraphQL schema")
-    const context =
-      store.graphQLContext ?? shouldNeverHappen("Can't run a GraphQL query on a store without GraphQL context")
-
-    const operationName = graphql.getOperationAST(document)?.name?.value
-
-    return otelTracer.startActiveSpan(`executeGraphQLQuery: ${operationName}`, {}, otelContext, (span) => {
-      span.setAttribute('graphql.variables', JSON.stringify(variableValues))
-      span.setAttribute('graphql.query', graphql.print(document))
-
-      context.queriedTables.clear()
-
-      context.otelContext = otel.trace.setSpan(otel.context.active(), span)
-
-      const res = graphql.executeSync({
-        document,
-        contextValue: context,
-        schema: schema,
-        variableValues,
-      })
-
-      // TODO track number of nested SQL queries via Otel + debug info
-
-      if (res.errors) {
-        span.setStatus({ code: otel.SpanStatusCode.ERROR, message: 'GraphQL error' })
-        span.setAttribute('graphql.error', res.errors.join('\n'))
-        span.setAttribute('graphql.error-detail', JSON.stringify(res.errors))
-        console.error(`graphql error (${operationName}) - ${res.errors.length} errors`)
-        for (const error of res.errors) {
-          console.error(error)
-        }
-        debugger
-        shouldNeverHappen(`GraphQL error: ${res.errors.join('\n')}`)
-      }
-
-      span.end()
-
-      const result = this.mapResult(res.data as unknown as TResult, get)
-
-      const durationMs = getDurationMsFromSpan(span)
-
-      this.executionTimes.push(durationMs)
-
-      return {
-        result,
-        queriedTables: Array.from(context.queriedTables.values()),
-        durationMs,
-      }
-    })
-  }
-
-  destroy = () => {
-    if (this.variableValues$ !== undefined) {
-      this.reactivityGraph.destroyNode(this.variableValues$)
-    }
-
-    this.reactivityGraph.destroyNode(this.results$)
-  }
-}

package/src/row-query-utils.ts

@@ -1,65 +0,0 @@
-import type { PreparedBindValues, QueryInfo } from '@livestore/common'
-import { SessionIdSymbol } from '@livestore/common'
-import { DbSchema } from '@livestore/common/schema'
-import { shouldNeverHappen } from '@livestore/utils'
-import type * as otel from '@opentelemetry/api'
-
-import type { LiveQuery, LiveQueryAny, QueryContext } from './live-queries/base-class.js'
-import { computed } from './live-queries/computed.js'
-
-export const rowQueryLabel = (table: DbSchema.TableDefBase, id: string | SessionIdSymbol | undefined) =>
-  `row:${table.sqliteDef.name}${id === undefined ? '' : id === SessionIdSymbol ? `:sessionId` : `:${id}`}`
-
-export const deriveColQuery: {
-  <TQuery extends LiveQuery<any, QueryInfo.None>, TCol extends keyof TQuery['__result!'] & string>(
-    query$: TQuery,
-    colName: TCol,
-  ): LiveQuery<TQuery['__result!'][TCol], QueryInfo.None>
-  <TQuery extends LiveQuery<any, QueryInfo.Row>, TCol extends keyof TQuery['__result!'] & string>(
-    query$: TQuery,
-    colName: TCol,
-  ): LiveQuery<TQuery['__result!'][TCol], QueryInfo.Col>
-} = (query$: LiveQueryAny, colName: string) => {
-  return computed((get) => get(query$)[colName], {
-    label: `deriveColQuery:${query$.label}:${colName}`,
-    queryInfo:
-      query$.queryInfo._tag === 'Row'
-        ? { _tag: 'Col', table: query$.queryInfo.table, column: colName, id: query$.queryInfo.id }
-        : undefined,
-  }) as any
-}
-
-export const makeExecBeforeFirstRun =
-  ({
-    id,
-    insertValues,
-    table,
-    otelContext: otelContext_,
-  }: {
-    id?: string | SessionIdSymbol
-    insertValues?: any
-    table: DbSchema.TableDefBase
-    otelContext: otel.Context | undefined
-  }) =>
-  ({ store }: QueryContext) => {
-    const otelContext = otelContext_ ?? store.otel.queriesSpanContext
-
-    if (table.options.isSingleton === false) {
-      const idStr = id === SessionIdSymbol ? store.sessionId : id!
-      const rowExists =
-        store.syncDbWrapper.select(`SELECT 1 FROM '${table.sqliteDef.name}' WHERE id = ?`, {
-          bindValues: [idStr] as any as PreparedBindValues,
-        }).length === 1
-
-      if (rowExists) return
-
-      if (DbSchema.tableHasDerivedMutations(table) === false) {
-        return shouldNeverHappen(
-          `Cannot insert row for table "${table.sqliteDef.name}" which does not have 'deriveMutations: true' set`,
-        )
-      }
-
-      // NOTE It's important that we only mutate and don't refresh here, as this function is called during a render
-      store.mutate({ otelContext, skipRefresh: true }, table.insert({ id, ...insertValues }))
-    }
-  }

package/src/utils/otel.ts

@@ -1,9 +0,0 @@
-import type * as otel from '@opentelemetry/api'
-
-export const getDurationMsFromSpan = (span: otel.Span): number => {
-  const durationHr: [seconds: number, nanos: number] = (span as any)._duration
-  return durationHr[0] * 1000 + durationHr[1] / 1_000_000
-}
-
-export const getStartTimeHighResFromSpan = (span: otel.Span): DOMHighResTimeStamp =>
-  (span as any)._performanceStartTime as DOMHighResTimeStamp

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    // "jsx": "preserve",
-    "tsBuildInfoFile": "./dist/.tsbuildinfo"
-  },
-  "include": ["./src"],
-  "references": [
-    { "path": "../db-schema" },
-    { "path": "../common" },
-    { "path": "../web" },
-    { "path": "../utils" }
-  ]
-}

package/vitest.config.js

@@ -1,9 +0,0 @@
-import { defineConfig } from 'vite'
-
-export default defineConfig({
-  resolve: {
-    alias: {
-      '@livestore/wa-sqlite/dist/wa-sqlite.mjs': '@livestore/wa-sqlite/dist/wa-sqlite.node.mjs',
-    },
-  },
-})