@livestore/common 0.0.54-dev.5 → 0.0.55-dev.0

package/src/schema-management/migrations.ts

@@ -1,6 +1,5 @@
 import { memoizeByStringifyArgs } from '@livestore/utils'
-import { Schema as EffectSchema } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
+import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
 import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 import type { InMemoryDatabase } from '../adapter-types.js'
@@ -20,130 +19,144 @@ import { validateSchema } from './validate-mutation-defs.js'
 
 const getMemoizedTimestamp = memoizeByStringifyArgs(() => new Date().toISOString())
 
-export const makeSchemaManager = (db: InMemoryDatabase): SchemaManager => {
-  migrateTable({
-    db,
-    otelContext: otel.context.active(),
-    tableAst: schemaMutationsMetaTable.sqliteDef.ast,
-    behaviour: 'create-if-not-exists',
+export const makeSchemaManager = (db: InMemoryDatabase): Effect.Effect<SchemaManager> =>
+  Effect.gen(function* () {
+    yield* migrateTable({
+      db,
+      tableAst: schemaMutationsMetaTable.sqliteDef.ast,
+      behaviour: 'create-if-not-exists',
+    })
+
+    return {
+      getMutationDefInfos: () => {
+        const schemaMutationsMetaRows = dbSelect<SchemaMutationsMetaRow>(
+          db,
+          sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`,
+        )
+
+        return schemaMutationsMetaRows
+      },
+      setMutationDefInfo: (info) => {
+        dbExecute(
+          db,
+          sql`INSERT OR REPLACE INTO ${SCHEMA_MUTATIONS_META_TABLE} (mutationName, schemaHash, updatedAt) VALUES ($mutationName, $schemaHash, $updatedAt)`,
+          {
+            mutationName: info.mutationName,
+            schemaHash: info.schemaHash,
+            updatedAt: new Date().toISOString(),
+          },
+        )
+      },
+    }
   })
 
-  return {
-    getMutationDefInfos: () => {
-      const schemaMutationsMetaRows = dbSelect<SchemaMutationsMetaRow>(
-        db,
-        sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`,
-      )
-
-      return schemaMutationsMetaRows
-    },
-    setMutationDefInfo: (info) => {
-      dbExecute(
-        db,
-        sql`INSERT OR REPLACE INTO ${SCHEMA_MUTATIONS_META_TABLE} (mutationName, schemaHash, updatedAt) VALUES ($mutationName, $schemaHash, $updatedAt)`,
-        {
-          mutationName: info.mutationName,
-          schemaHash: info.schemaHash,
-          updatedAt: new Date().toISOString(),
-        },
-      )
-    },
-  }
-}
-
 // TODO more graceful DB migration (e.g. backup DB before destructive migrations)
 export const migrateDb = ({
   db,
-  otelContext = otel.context.active(),
   schema,
+  onProgress,
 }: {
   db: InMemoryDatabase
-  otelContext?: otel.Context
   schema: LiveStoreSchema
-}) => {
-  migrateTable({
-    db,
-    otelContext,
-    tableAst: schemaMetaTable.sqliteDef.ast,
-    behaviour: 'create-if-not-exists',
-  })
+  onProgress?: (opts: { done: number; total: number }) => Effect.Effect<void>
+}) =>
+  Effect.gen(function* () {
+    yield* migrateTable({
+      db,
+      tableAst: schemaMetaTable.sqliteDef.ast,
+      behaviour: 'create-if-not-exists',
+    })
 
-  validateSchema(schema, makeSchemaManager(db))
+    // TODO enforce that migrating tables isn't allowed once the store is running
 
-  const schemaMetaRows = dbSelect<SchemaMetaRow>(db, sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
+    const schemaManager = yield* makeSchemaManager(db)
+    yield* validateSchema(schema, schemaManager)
 
-  const dbSchemaHashByTable = Object.fromEntries(
-    schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
-  )
+    const schemaMetaRows = dbSelect<SchemaMetaRow>(db, sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
 
-  const tableDefs = new Set([
-    // NOTE it's important the `SCHEMA_META_TABLE` comes first since we're writing to it below
-    ...systemTables,
-    ...Array.from(schema.tables.values()).filter((_) => _.sqliteDef.name !== SCHEMA_META_TABLE),
-  ])
+    const dbSchemaHashByTable = Object.fromEntries(
+      schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
+    )
 
-  for (const tableDef of tableDefs) {
-    const tableAst = tableDef.sqliteDef.ast
-    const tableName = tableAst.name
-    const dbSchemaHash = dbSchemaHashByTable[tableName]
-    const schemaHash = SqliteAst.hash(tableAst)
+    const tableDefs = new Set([
+      // NOTE it's important the `SCHEMA_META_TABLE` comes first since we're writing to it below
+      ...systemTables,
+      ...Array.from(schema.tables.values()).filter((_) => _.sqliteDef.name !== SCHEMA_META_TABLE),
+    ])
 
-    const skipMigrations = import.meta.env.VITE_LIVESTORE_SKIP_MIGRATIONS !== undefined
+    const tablesToMigrate = new Set<{ tableAst: SqliteAst.Table; schemaHash: number }>()
 
-    if (schemaHash !== dbSchemaHash && skipMigrations === false) {
-      console.log(
-        `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
-      )
+    for (const tableDef of tableDefs) {
+      const tableAst = tableDef.sqliteDef.ast
+      const tableName = tableAst.name
+      const dbSchemaHash = dbSchemaHashByTable[tableName]
+      const schemaHash = SqliteAst.hash(tableAst)
+
+      if (schemaHash !== dbSchemaHash) {
+        tablesToMigrate.add({ tableAst, schemaHash })
 
-      migrateTable({ db, tableAst, otelContext, schemaHash, behaviour: 'drop-and-recreate' })
+        console.log(
+          `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
+        )
+      }
     }
-  }
-}
+
+    let processedTables = 0
+    const tablesCount = tablesToMigrate.size
+
+    for (const { tableAst, schemaHash } of tablesToMigrate) {
+      yield* migrateTable({ db, tableAst, schemaHash, behaviour: 'create-if-not-exists' })
+
+      if (onProgress !== undefined) {
+        processedTables++
+        yield* onProgress({ done: processedTables, total: tablesCount })
+      }
+    }
+  })
 
 export const migrateTable = ({
   db,
   tableAst,
-  // otelContext,
   schemaHash = SqliteAst.hash(tableAst),
   behaviour,
   skipMetaTable = false,
 }: {
   db: InMemoryDatabase
   tableAst: SqliteAst.Table
-  otelContext?: otel.Context
   schemaHash?: number
   behaviour: 'drop-and-recreate' | 'create-if-not-exists'
   skipMetaTable?: boolean
-}) => {
-  console.log(`Migrating table '${tableAst.name}'...`)
-  const tableName = tableAst.name
-  const columnSpec = makeColumnSpec(tableAst)
-
-  if (behaviour === 'drop-and-recreate') {
-    // TODO need to possibly handle cascading deletes due to foreign keys
-    dbExecute(db, sql`drop table if exists ${tableName}`)
-    dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
-  } else if (behaviour === 'create-if-not-exists') {
-    dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
-  }
+}) =>
+  Effect.gen(function* () {
+    console.log(`Migrating table '${tableAst.name}'...`)
+    const tableName = tableAst.name
+    const columnSpec = makeColumnSpec(tableAst)
+
+    if (behaviour === 'drop-and-recreate') {
+      // TODO need to possibly handle cascading deletes due to foreign keys
+      dbExecute(db, sql`drop table if exists ${tableName}`)
+      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+    } else if (behaviour === 'create-if-not-exists') {
+      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+    }
 
-  for (const index of tableAst.indexes) {
-    dbExecute(db, createIndexFromDefinition(tableName, index))
-  }
+    for (const index of tableAst.indexes) {
+      dbExecute(db, createIndexFromDefinition(tableName, index))
+    }
 
-  if (skipMetaTable !== true) {
-    const updatedAt = getMemoizedTimestamp()
+    if (skipMetaTable !== true) {
+      const updatedAt = getMemoizedTimestamp()
 
-    dbExecute(
-      db,
-      sql`
+      dbExecute(
+        db,
+        sql`
       INSERT INTO ${SCHEMA_META_TABLE} (tableName, schemaHash, updatedAt) VALUES ($tableName, $schemaHash, $updatedAt)
         ON CONFLICT (tableName) DO UPDATE SET schemaHash = $schemaHash, updatedAt = $updatedAt;
     `,
-      { tableName, schemaHash, updatedAt },
-    )
-  }
-}
+        { tableName, schemaHash, updatedAt },
+      )
+    }
+  }).pipe(Effect.withSpan('@livestore/common:migrateTable', { attributes: { tableName: tableAst.name } }))
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
   const uniqueStr = index.unique ? 'UNIQUE' : ''

package/src/schema-management/validate-mutation-defs.ts

@@ -1,32 +1,35 @@
-import { shouldNeverHappen } from '@livestore/utils'
-import { Schema } from '@livestore/utils/effect'
+import { Effect, Schema } from '@livestore/utils/effect'
 
+import { UnexpectedError } from '../adapter-types.js'
 import type { LiveStoreSchema } from '../schema/index.js'
 import type { MutationDef } from '../schema/mutations.js'
 import type { MutationDefInfo, SchemaManager } from './common.js'
 
-export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaManager) => {
-  // Validate mutation definitions
-  const registeredMutationDefInfos = schemaManager.getMutationDefInfos()
+export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaManager) =>
+  Effect.gen(function* () {
+    // Validate mutation definitions
+    const registeredMutationDefInfos = schemaManager.getMutationDefInfos()
 
-  const missingMutationDefs = registeredMutationDefInfos.filter(
-    (registeredMutationDefInfo) => !schema.mutations.has(registeredMutationDefInfo.mutationName),
-  )
-
-  if (missingMutationDefs.length > 0) {
-    shouldNeverHappen(
-      `Missing mutation definitions: ${missingMutationDefs.map((info) => info.mutationName).join(', ')}`,
+    const missingMutationDefs = registeredMutationDefInfos.filter(
+      (registeredMutationDefInfo) => !schema.mutations.has(registeredMutationDefInfo.mutationName),
     )
-  }
 
-  for (const [, mutationDef] of schema.mutations) {
-    const registeredMutationDefInfo = registeredMutationDefInfos.find((info) => info.mutationName === mutationDef.name)
+    if (missingMutationDefs.length > 0) {
+      yield* new UnexpectedError({
+        cause: `Missing mutation definitions: ${missingMutationDefs.map((info) => info.mutationName).join(', ')}`,
+      })
+    }
 
-    validateMutationDef(mutationDef, schemaManager, registeredMutationDefInfo)
-  }
+    for (const [, mutationDef] of schema.mutations) {
+      const registeredMutationDefInfo = registeredMutationDefInfos.find(
+        (info) => info.mutationName === mutationDef.name,
+      )
 
-  // Validate table schemas
-}
+      validateMutationDef(mutationDef, schemaManager, registeredMutationDefInfo)
+    }
+
+    // Validate table schemas
+  })
 
 export const validateMutationDef = (
   mutationDef: MutationDef.Any,

package/src/util.ts

@@ -12,7 +12,7 @@ export const SqlValueSchema = Schema.Union(Schema.String, Schema.Number, Schema.
 
 export const PreparedBindValues = Schema.Union(
   Schema.Array(SqlValueSchema),
-  Schema.Record(Schema.String, SqlValueSchema),
+  Schema.Record({ key: Schema.String, value: SqlValueSchema }),
 ).pipe(Schema.brand('PreparedBindValues'))
 
 export type PreparedBindValues = Brand.Branded<Bindable, 'PreparedBindValues'>

package/src/version.ts

@@ -0,0 +1,3 @@
+import packageJson from '../package.json' with { type: 'json' }
+
+export const liveStoreVersion = packageJson.version

package/dist/devtools/index copy.d.ts

@@ -1,214 +0,0 @@
-import { Schema } from '@livestore/utils/effect';
-declare const SnapshotReq_base: Schema.TaggedStruct<"LSD.SnapshotReq", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-}>;
-export declare class SnapshotReq extends SnapshotReq_base {
-}
-declare const SnapshotRes_base: Schema.TaggedStruct<"LSD.SnapshotRes", {
-    requestId: typeof Schema.String;
-    snapshot: Schema.Schema<Uint8Array, readonly number[], never>;
-}>;
-export declare class SnapshotRes extends SnapshotRes_base {
-}
-declare const DebugInfoReq_base: Schema.TaggedStruct<"LSD.DebugInfoReq", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-}>;
-export declare class DebugInfoReq extends DebugInfoReq_base {
-}
-declare const DebugInfoRes_base: Schema.TaggedStruct<"LSD.DebugInfoRes", {
-    requestId: typeof Schema.String;
-    debugInfo: Schema.Struct<{
-        slowQueries: Schema.transform<Schema.Struct<{
-            size: typeof Schema.Number;
-            items: Schema.Array$<Schema.Schema<{
-                readonly queryStr: string;
-                readonly bindValues: ((readonly (string | number | Uint8Array | null)[] | {
-                    readonly [x: string]: string | number | Uint8Array | null;
-                }) & import("effect/Brand").Brand<"PreparedBindValues">) | undefined;
-                readonly durationMs: number;
-                readonly rowsCount: number | undefined;
-                readonly queriedTables: ReadonlySet<string>;
-                readonly startTimePerfNow: number;
-            }, {
-                readonly queryStr: string;
-                readonly bindValues: readonly (string | number | readonly number[] | null)[] | {
-                    readonly [x: string]: string | number | readonly number[] | null;
-                } | undefined;
-                readonly durationMs: number;
-                readonly rowsCount: number | undefined;
-                readonly queriedTables: readonly string[];
-                readonly startTimePerfNow: number;
-            }, never>>;
-        }>, Schema.Schema<import("../bounded-collections.js").BoundArray<{
-            readonly queryStr: string;
-            readonly bindValues: ((readonly (string | number | Uint8Array | null)[] | {
-                readonly [x: string]: string | number | Uint8Array | null;
-            }) & import("effect/Brand").Brand<"PreparedBindValues">) | undefined;
-            readonly durationMs: number;
-            readonly rowsCount: number | undefined;
-            readonly queriedTables: ReadonlySet<string>;
-            readonly startTimePerfNow: number;
-        }>, import("../bounded-collections.js").BoundArray<{
-            readonly queryStr: string;
-            readonly bindValues: ((readonly (string | number | Uint8Array | null)[] | {
-                readonly [x: string]: string | number | Uint8Array | null;
-            }) & import("effect/Brand").Brand<"PreparedBindValues">) | undefined;
-            readonly durationMs: number;
-            readonly rowsCount: number | undefined;
-            readonly queriedTables: ReadonlySet<string>;
-            readonly startTimePerfNow: number;
-        }>, never>>;
-        queryFrameDuration: typeof Schema.Number;
-        queryFrameCount: typeof Schema.Number;
-        events: Schema.transform<Schema.Struct<{
-            size: typeof Schema.Number;
-            items: Schema.Array$<Schema.Schema<readonly [string, any], readonly [string, any], never>>;
-        }>, Schema.Schema<import("../bounded-collections.js").BoundArray<readonly [string, any]>, import("../bounded-collections.js").BoundArray<readonly [string, any]>, never>>;
-    }>;
-}>;
-export declare class DebugInfoRes extends DebugInfoRes_base {
-}
-declare const DebugInfoResetReq_base: Schema.TaggedStruct<"LSD.DebugInfoResetReq", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-}>;
-export declare class DebugInfoResetReq extends DebugInfoResetReq_base {
-}
-declare const DebugInfoResetRes_base: Schema.TaggedStruct<"LSD.DebugInfoResetRes", {
-    requestId: typeof Schema.String;
-}>;
-export declare class DebugInfoResetRes extends DebugInfoResetRes_base {
-}
-declare const DebugInfoRerunQueryReq_base: Schema.TaggedStruct<"LSD.DebugInfoRerunQueryReq", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-    queryStr: typeof Schema.String;
-    bindValues: Schema.UndefinedOr<Schema.brand<Schema.Union<[Schema.Array$<Schema.Union<[typeof Schema.String, typeof Schema.Number, Schema.Schema<Uint8Array, readonly number[], never>, typeof Schema.Null]>>, Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, typeof Schema.Number, Schema.Schema<Uint8Array, readonly number[], never>, typeof Schema.Null]>>]>, "PreparedBindValues">>;
-    queriedTables: Schema.ReadonlySet$<typeof Schema.String>;
-}>;
-export declare class DebugInfoRerunQueryReq extends DebugInfoRerunQueryReq_base {
-}
-declare const DebugInfoRerunQueryRes_base: Schema.TaggedStruct<"LSD.DebugInfoRerunQueryRes", {
-    requestId: typeof Schema.String;
-}>;
-export declare class DebugInfoRerunQueryRes extends DebugInfoRerunQueryRes_base {
-}
-declare const MutationBroadcast_base: Schema.TaggedStruct<"LSD.MutationBroadcast", {
-    requestId: typeof Schema.String;
-    mutationEventEncoded: Schema.Struct<{
-        mutation: typeof Schema.String;
-        args: typeof Schema.Any;
-        id: typeof Schema.String;
-    }>;
-    persisted: typeof Schema.Boolean;
-}>;
-export declare class MutationBroadcast extends MutationBroadcast_base {
-}
-declare const MutationLogReq_base: Schema.TaggedStruct<"LSD.MutationLogReq", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-}>;
-export declare class MutationLogReq extends MutationLogReq_base {
-}
-declare const MutationLogRes_base: Schema.TaggedStruct<"LSD.MutationLogRes", {
-    requestId: typeof Schema.String;
-    mutationLog: Schema.Schema<Uint8Array, readonly number[], never>;
-}>;
-export declare class MutationLogRes extends MutationLogRes_base {
-}
-declare const SignalsSubscribe_base: Schema.TaggedStruct<"LSD.SignalsSubscribe", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-    includeResults: typeof Schema.Boolean;
-}>;
-export declare class SignalsSubscribe extends SignalsSubscribe_base {
-}
-declare const SignalsUnsubscribe_base: Schema.TaggedStruct<"LSD.SignalsUnsubscribe", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-}>;
-export declare class SignalsUnsubscribe extends SignalsUnsubscribe_base {
-}
-declare const SignalsRes_base: Schema.TaggedStruct<"LSD.SignalsRes", {
-    requestId: typeof Schema.String;
-    signals: typeof Schema.Any;
-}>;
-export declare class SignalsRes extends SignalsRes_base {
-}
-declare const LiveQueriesSubscribe_base: Schema.TaggedStruct<"LSD.LiveQueriesSubscribe", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-}>;
-export declare class LiveQueriesSubscribe extends LiveQueriesSubscribe_base {
-}
-declare const LiveQueriesUnsubscribe_base: Schema.TaggedStruct<"LSD.LiveQueriesUnsubscribe", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-}>;
-export declare class LiveQueriesUnsubscribe extends LiveQueriesUnsubscribe_base {
-}
-declare const SerializedLiveQuery_base: Schema.Struct<{
-    _tag: Schema.Literal<["js", "sql", "graphql"]>;
-    id: typeof Schema.Number;
-    label: typeof Schema.String;
-    runs: typeof Schema.Number;
-    executionTimes: Schema.Array$<typeof Schema.Number>;
-    lastestResult: typeof Schema.Any;
-    activeSubscriptions: Schema.Array$<Schema.Struct<{
-        frames: Schema.Array$<Schema.Struct<{
-            name: typeof Schema.String;
-            filePath: typeof Schema.String;
-        }>>;
-    }>>;
-}>;
-export declare class SerializedLiveQuery extends SerializedLiveQuery_base {
-}
-declare const LiveQueriesRes_base: Schema.TaggedStruct<"LSD.LiveQueriesRes", {
-    requestId: typeof Schema.String;
-    liveQueries: Schema.Array$<typeof SerializedLiveQuery>;
-}>;
-export declare class LiveQueriesRes extends LiveQueriesRes_base {
-}
-declare const ResetAllDataReq_base: Schema.TaggedStruct<"LSD.ResetAllDataReq", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-    mode: Schema.Literal<["all-data", "only-app-db"]>;
-}>;
-export declare class ResetAllDataReq extends ResetAllDataReq_base {
-}
-declare const ResetAllDataRes_base: Schema.TaggedStruct<"LSD.ResetAllDataRes", {
-    requestId: typeof Schema.String;
-}>;
-export declare class ResetAllDataRes extends ResetAllDataRes_base {
-}
-declare const DevtoolsReadyBroadcast_base: Schema.TaggedStruct<"LSD.DevtoolsReadyBroadcast", {}>;
-export declare class DevtoolsReadyBroadcast extends DevtoolsReadyBroadcast_base {
-}
-declare const AppHostReadyBroadcast_base: Schema.TaggedStruct<"LSD.AppHostReadyBroadcast", {
-    channelId: typeof Schema.String;
-}>;
-export declare class AppHostReadyBroadcast extends AppHostReadyBroadcast_base {
-}
-declare const Disconnect_base: Schema.TaggedStruct<"LSD.Disconnect", {
-    requestId: typeof Schema.String;
-    channelId: typeof Schema.String;
-}>;
-export declare class Disconnect extends Disconnect_base {
-}
-declare const SchemaChanged_base: Schema.TaggedStruct<"LSD.SchemaChanged", {
-    requestId: typeof Schema.String;
-}>;
-export declare class SchemaChanged extends SchemaChanged_base {
-}
-export declare const MessageToAppHost: Schema.Union<[typeof SnapshotReq, typeof MutationLogReq, typeof DebugInfoReq, typeof DebugInfoResetReq, typeof DebugInfoRerunQueryReq, typeof SignalsSubscribe, typeof SignalsUnsubscribe, typeof LiveQueriesSubscribe, typeof LiveQueriesUnsubscribe, typeof ResetAllDataReq, typeof DevtoolsReadyBroadcast, typeof Disconnect]>;
-export type MessageToAppHost = typeof MessageToAppHost.Type;
-export declare const MessageFromAppHost: Schema.Union<[typeof SnapshotRes, typeof MutationLogRes, typeof DebugInfoRes, typeof DebugInfoResetRes, typeof DebugInfoRerunQueryRes, typeof SignalsRes, typeof LiveQueriesRes, typeof ResetAllDataRes, typeof Disconnect, typeof SchemaChanged, typeof MutationBroadcast, typeof AppHostReadyBroadcast]>;
-export type MessageFromAppHost = typeof MessageFromAppHost.Type;
-export declare const makeBroadcastChannels: () => {
-    fromAppHost: BroadcastChannel;
-    toAppHost: BroadcastChannel;
-};
-export {};
-//# sourceMappingURL=index%20copy.d.ts.map

package/dist/devtools/index copy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index copy.d.ts","sourceRoot":"","sources":["../../src/devtools/index copy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;;;;;AAUhD,qBAAa,WAAY,SAAQ,gBAG/B;CAAG;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAG/B;CAAG;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAGhC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAGhC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAErC;CAAG;;;;;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAM1C;CAAG;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAE1C;CAAG;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG;;;;;;AAEL,qBAAa,gBAAiB,SAAQ,qBAIpC;CAAG;;;;;AAEL,qBAAa,kBAAmB,SAAQ,uBAGtC;CAAG;;;;;AAEL,qBAAa,UAAW,SAAQ,eAG9B;CAAG;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAGxC;CAAG;;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAG1C;CAAG;;;;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAUvC;CAAG;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAInC;CAAG;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAEnC;CAAG;;AAEL,qBAAa,sBAAuB,SAAQ,2BAAqD;CAAG;;;;AAEpG,qBAAa,qBAAsB,SAAQ,0BAEzC;CAAG;;;;;AAEL,qBAAa,UAAW,SAAQ,eAG9B;CAAG;;;;AAEL,qBAAa,aAAc,SAAQ,kBAEjC;CAAG;AAEL,eAAO,MAAM,gBAAgB,mUAa5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,eAAO,MAAM,kBAAkB,4SAa9B,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA;AAG/D,eAAO,MAAM,qBAAqB;;;CAGhC,CAAA"}

package/dist/devtools/index copy.js

@@ -1,137 +0,0 @@
-import { Schema } from '@livestore/utils/effect';
-import { DebugInfo } from '../debug-info.js';
-import { mutationEventSchemaEncodedAny } from '../schema/mutations.js';
-import { PreparedBindValues } from '../util.js';
-const requestId = Schema.String;
-const channelId = Schema.String;
-export class SnapshotReq extends Schema.TaggedStruct('LSD.SnapshotReq', {
-    requestId,
-    channelId,
-}) {
-}
-export class SnapshotRes extends Schema.TaggedStruct('LSD.SnapshotRes', {
-    requestId,
-    snapshot: Schema.Uint8Array,
-}) {
-}
-export class DebugInfoReq extends Schema.TaggedStruct('LSD.DebugInfoReq', {
-    requestId,
-    channelId,
-}) {
-}
-export class DebugInfoRes extends Schema.TaggedStruct('LSD.DebugInfoRes', {
-    requestId,
-    debugInfo: DebugInfo,
-}) {
-}
-export class DebugInfoResetReq extends Schema.TaggedStruct('LSD.DebugInfoResetReq', {
-    requestId,
-    channelId,
-}) {
-}
-export class DebugInfoResetRes extends Schema.TaggedStruct('LSD.DebugInfoResetRes', {
-    requestId,
-}) {
-}
-export class DebugInfoRerunQueryReq extends Schema.TaggedStruct('LSD.DebugInfoRerunQueryReq', {
-    requestId,
-    channelId,
-    queryStr: Schema.String,
-    bindValues: Schema.UndefinedOr(PreparedBindValues),
-    queriedTables: Schema.ReadonlySet(Schema.String),
-}) {
-}
-export class DebugInfoRerunQueryRes extends Schema.TaggedStruct('LSD.DebugInfoRerunQueryRes', {
-    requestId,
-}) {
-}
-export class MutationBroadcast extends Schema.TaggedStruct('LSD.MutationBroadcast', {
-    requestId,
-    mutationEventEncoded: mutationEventSchemaEncodedAny,
-    persisted: Schema.Boolean,
-}) {
-}
-export class MutationLogReq extends Schema.TaggedStruct('LSD.MutationLogReq', {
-    requestId,
-    channelId,
-}) {
-}
-export class MutationLogRes extends Schema.TaggedStruct('LSD.MutationLogRes', {
-    requestId,
-    mutationLog: Schema.Uint8Array,
-}) {
-}
-export class SignalsSubscribe extends Schema.TaggedStruct('LSD.SignalsSubscribe', {
-    requestId,
-    channelId,
-    includeResults: Schema.Boolean,
-}) {
-}
-export class SignalsUnsubscribe extends Schema.TaggedStruct('LSD.SignalsUnsubscribe', {
-    requestId,
-    channelId,
-}) {
-}
-export class SignalsRes extends Schema.TaggedStruct('LSD.SignalsRes', {
-    requestId,
-    signals: Schema.Any,
-}) {
-}
-export class LiveQueriesSubscribe extends Schema.TaggedStruct('LSD.LiveQueriesSubscribe', {
-    requestId,
-    channelId,
-}) {
-}
-export class LiveQueriesUnsubscribe extends Schema.TaggedStruct('LSD.LiveQueriesUnsubscribe', {
-    requestId,
-    channelId,
-}) {
-}
-export class SerializedLiveQuery extends Schema.Struct({
-    _tag: Schema.Literal('js', 'sql', 'graphql'),
-    id: Schema.Number,
-    label: Schema.String,
-    runs: Schema.Number,
-    executionTimes: Schema.Array(Schema.Number),
-    lastestResult: Schema.Any,
-    activeSubscriptions: Schema.Array(Schema.Struct({ frames: Schema.Array(Schema.Struct({ name: Schema.String, filePath: Schema.String })) })),
-}) {
-}
-export class LiveQueriesRes extends Schema.TaggedStruct('LSD.LiveQueriesRes', {
-    requestId,
-    liveQueries: Schema.Array(SerializedLiveQuery),
-}) {
-}
-export class ResetAllDataReq extends Schema.TaggedStruct('LSD.ResetAllDataReq', {
-    requestId,
-    channelId,
-    mode: Schema.Literal('all-data', 'only-app-db'),
-}) {
-}
-export class ResetAllDataRes extends Schema.TaggedStruct('LSD.ResetAllDataRes', {
-    requestId,
-}) {
-}
-export class DevtoolsReadyBroadcast extends Schema.TaggedStruct('LSD.DevtoolsReadyBroadcast', {}) {
-}
-export class AppHostReadyBroadcast extends Schema.TaggedStruct('LSD.AppHostReadyBroadcast', {
-    channelId,
-}) {
-}
-export class Disconnect extends Schema.TaggedStruct('LSD.Disconnect', {
-    requestId,
-    channelId,
-}) {
-}
-export class SchemaChanged extends Schema.TaggedStruct('LSD.SchemaChanged', {
-    requestId,
-}) {
-}
-export const MessageToAppHost = Schema.Union(SnapshotReq, MutationLogReq, DebugInfoReq, DebugInfoResetReq, DebugInfoRerunQueryReq, SignalsSubscribe, SignalsUnsubscribe, LiveQueriesSubscribe, LiveQueriesUnsubscribe, ResetAllDataReq, DevtoolsReadyBroadcast, Disconnect);
-export const MessageFromAppHost = Schema.Union(SnapshotRes, MutationLogRes, DebugInfoRes, DebugInfoResetRes, DebugInfoRerunQueryRes, SignalsRes, LiveQueriesRes, ResetAllDataRes, Disconnect, SchemaChanged, MutationBroadcast, AppHostReadyBroadcast);
-// TODO make specific over app key
-export const makeBroadcastChannels = () => ({
-    fromAppHost: new BroadcastChannel(`livestore-devtools-from-app-host`),
-    toAppHost: new BroadcastChannel(`livestore-devtools-to-app-host`),
-});
-//# sourceMappingURL=index%20copy.js.map