@livestore/common 0.0.54-dev.0 → 0.0.54-dev.1

package/src/devtools/devtools-messages.ts

@@ -0,0 +1,186 @@
+import { Schema } from '@livestore/utils/effect'
+import { type SqliteDsl as __SqliteDsl } from 'effect-db-schema'
+
+import { NetworkStatus } from '../adapter-types.js'
+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 NetworkStatusBroadcast extends Schema.TaggedStruct('LSD.NetworkStatusBroadcast', {
+  channelId,
+  networkStatus: NetworkStatus,
+}) {}
+
+export class DevtoolsReadyBroadcast extends Schema.TaggedStruct('LSD.DevtoolsReadyBroadcast', {}) {}
+
+export class DevtoolsConnected extends Schema.TaggedStruct('LSD.DevtoolsConnected', {
+  channelId,
+}) {}
+
+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,
+  DevtoolsConnected,
+)
+
+export type MessageToAppHost = typeof MessageToAppHost.Type
+
+export const MessageFromAppHost = Schema.Union(
+  SnapshotRes,
+  MutationLogRes,
+  DebugInfoRes,
+  DebugInfoResetRes,
+  DebugInfoRerunQueryRes,
+  SignalsRes,
+  LiveQueriesRes,
+  ResetAllDataRes,
+  Disconnect,
+  // SchemaChanged,
+  MutationBroadcast,
+  AppHostReadyBroadcast,
+  NetworkStatusBroadcast,
+)
+
+export type MessageFromAppHost = typeof MessageFromAppHost.Type
+
+// 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`),
+})

package/src/devtools/index.ts

@@ -1,146 +1 @@
-import { Schema } from '@livestore/utils/effect'
-import { type SqliteDsl as __SqliteDsl } from 'effect-db-schema'
-
-import { LiveStoreSchemaSchema } from '../schema/index.js'
-import { mutationEventSchemaEncodedAny } from '../schema/mutations.js'
-
-const requestId = Schema.String
-
-export class SnapshotReq extends Schema.TaggedStruct('LSD.SnapshotReq', {
-  requestId,
-}) {}
-
-export class SnapshotRes extends Schema.TaggedStruct('LSD.SnapshotRes', {
-  requestId,
-  snapshot: Schema.Uint8Array,
-}) {}
-
-export class SerializedSchemaReq extends Schema.TaggedStruct('LSD.SerializedSchemaReq', {
-  requestId,
-}) {}
-
-export class SerializedSchemaRes extends Schema.TaggedStruct('LSD.SerializedSchemaRes', {
-  requestId,
-  schema: LiveStoreSchemaSchema,
-}) {}
-
-export class MutationBroadcast extends Schema.TaggedStruct('LSD.MutationBroadcast', {
-  requestId,
-  mutationEventEncoded: mutationEventSchemaEncodedAny,
-  persisted: Schema.Boolean,
-}) {}
-
-export class MutationLogReq extends Schema.TaggedStruct('LSD.MutationLogReq', {
-  requestId,
-}) {}
-
-export class MutationLogRes extends Schema.TaggedStruct('LSD.MutationLogRes', {
-  requestId,
-  mutationLog: Schema.Uint8Array,
-}) {}
-
-export class SubscribeSignalsReq extends Schema.TaggedStruct('LSD.SubscribeSignalsReq', {
-  requestId,
-  includeResults: Schema.Boolean,
-}) {}
-
-export class SubscribeSignalsRes extends Schema.TaggedStruct('LSD.SubscribeSignalsRes', {
-  requestId,
-  signals: Schema.Any,
-}) {}
-
-export class SubscribeLiveQueriesReq extends Schema.TaggedStruct('LSD.SubscribeLiveQueriesReq', {
-  requestId,
-}) {}
-
-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 SubscribeLiveQueriesRes extends Schema.TaggedStruct('LSD.SubscribeLiveQueriesRes', {
-  requestId,
-  liveQueries: Schema.Array(SerializedLiveQuery),
-}) {}
-
-export class ResetAllDataReq extends Schema.TaggedStruct('LSD.ResetAllDataReq', {
-  requestId,
-  mode: Schema.Literal('all-data', 'only-app-db'),
-}) {}
-
-export class ResetAllDataRes extends Schema.TaggedStruct('LSD.ResetAllDataRes', {
-  requestId,
-}) {}
-
-export class AppHostReadyReq extends Schema.TaggedStruct('LSD.AppHostReadyReq', {
-  requestId,
-}) {}
-export class AppHostReadyRes extends Schema.TaggedStruct('LSD.AppHostReadyRes', {
-  requestId,
-}) {}
-
-export class Disconnect extends Schema.TaggedStruct('LSD.Disconnect', {
-  requestId,
-}) {}
-
-export class SchemaChanged extends Schema.TaggedStruct('LSD.SchemaChanged', {
-  requestId,
-}) {}
-
-// export const Message = Schema.Union(
-//   SnapshotReq,
-//   SnapshotRes,
-//   SerializedSchemaReq,
-//   SerializedSchemaRes,
-//   MutationBroadcast,
-//   MutationLogReq,
-//   MutationLogRes,
-//   SubscribeSignalsReq,
-//   SubscribeSignalsRes,
-//   SubscribeLiveQueriesReq,
-//   SubscribeLiveQueriesRes,
-//   ResetAllDataReq,
-//   ResetAllDataRes,
-//   Disconnect,
-//   SchemaChanged,
-//   AppHostReadyReq,
-//   AppHostReadyRes,
-// )
-
-// export type Message = typeof Message.Type
-
-export const MessageToAppHost = Schema.Union(
-  SnapshotReq,
-  SerializedSchemaReq,
-  MutationLogReq,
-  SubscribeSignalsReq,
-  SubscribeLiveQueriesReq,
-  ResetAllDataReq,
-  AppHostReadyReq,
-)
-
-export type MessageToAppHost = typeof MessageToAppHost.Type
-
-export const MessageFromAppHost = Schema.Union(
-  SnapshotRes,
-  SerializedSchemaRes,
-  MutationLogRes,
-  SubscribeSignalsRes,
-  SubscribeLiveQueriesRes,
-  ResetAllDataRes,
-  AppHostReadyRes,
-  Disconnect,
-  SchemaChanged,
-  MutationBroadcast,
-)
-
-export type MessageFromAppHost = typeof MessageFromAppHost.Type
-
-export const makeBc = () => new BroadcastChannel('livestore-devtools')
+export * from './devtools-messages.js'

package/src/index.ts

@@ -9,3 +9,5 @@ export * from './query-info.js'
 export * from './derived-mutations.js'
 export * from './sync/index.js'
 export * as Devtools from './devtools/index.js'
+export * from './debug-info.js'
+export * from './bounded-collections.js'

package/src/schema/index.ts

@@ -1,7 +1,7 @@
-import { isReadonlyArray, pick, shouldNeverHappen } from '@livestore/utils'
+import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
 import type { ReadonlyArray } from '@livestore/utils/effect'
-import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
-import { SqliteAst, SqliteDsl } from 'effect-db-schema'
+import type { SqliteDsl } from 'effect-db-schema'
+import { SqliteAst } from 'effect-db-schema'
 
 import type { MigrationOptions } from '../adapter-types.js'
 import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
@@ -13,7 +13,7 @@ import {
   rawSqlMutation,
 } from './mutations.js'
 import { systemTables } from './system-tables.js'
-import { table, type TableDef, tableHasDerivedMutations } from './table-def.js'
+import { type TableDef, tableHasDerivedMutations } from './table-def.js'
 
 export * from './system-tables.js'
 export * as DbSchema from './table-def.js'
@@ -139,65 +139,3 @@ namespace FromInputSchema {
         ? { [K in keyof TMutations as TMutations[K]['name']]: TMutations[K] } & { 'livestore.RawSql': RawSqlMutation }
         : never
 }
-
-export const LiveStoreSchemaFromSelf: Schema.Schema<LiveStoreSchema> = Schema.declare(
-  (_): _ is LiveStoreSchema =>
-    (_ as any)._DbSchemaType === Symbol.for('livestore.DbSchemaType') &&
-    (_ as any)._MutationDefMapType === Symbol.for('livestore.MutationDefMapType'),
-  {
-    identifier: 'LiveStoreSchemaFromSelf',
-    pretty: () => (_) => `LiveStoreSchema(hash: ${_.hash})`,
-    arbitrary: () => (fc) => fc.anything as any,
-    equivalence: () => (a, b) => a.hash === b.hash,
-  },
-)
-
-export const TableDefColumnSchema = Schema.Struct({
-  columnType: Schema.Literal('blob', 'integer', 'text', 'real'),
-  nullable: Schema.Boolean,
-  primaryKey: Schema.Boolean,
-})
-
-export const TableDefSqliteSchema = Schema.Struct({
-  name: Schema.String,
-  columns: Schema.Record(Schema.String, TableDefColumnSchema),
-  ast: Schema.Any,
-})
-
-export const TableDefSchema = Schema.Struct({
-  sqliteDef: TableDefSqliteSchema,
-  isSingleColumn: Schema.Boolean,
-  options: Schema.Any,
-})
-
-export const LiveStoreSchemaSchema = Schema.transform(
-  Schema.Struct({
-    tables: Schema.Record(Schema.String, TableDefSchema),
-    // mutations: Schema.Record(Schema.String, MutationDef.AnySchema),
-    // migrationOptions: Schema.Struct({ strategy: Schema.Literal('hard-reset') }),
-  }),
-  LiveStoreSchemaFromSelf,
-  {
-    encode: (schema) => ({
-      tables: ReadonlyRecord.map(Object.fromEntries(schema.tables.entries()), (t) => ({
-        sqliteDef: {
-          name: t.sqliteDef.name,
-          columns: ReadonlyRecord.map(t.sqliteDef.columns, (c) => pick(c!, ['columnType', 'nullable', 'primaryKey'])),
-          ast: JSON.parse(JSON.stringify(t.sqliteDef.ast)),
-        },
-        isSingleColumn: t.isSingleColumn,
-        options: t.options,
-      })),
-    }),
-    decode: (schema) => {
-      const tables = ReadonlyRecord.map(schema.tables, (t) => {
-        const columns = ReadonlyRecord.map(t.sqliteDef.columns, (c) => {
-          const makeCol = SqliteDsl[c.columnType] as any
-          return makeCol({ nullable: c.nullable, primaryKey: c.primaryKey })
-        })
-        return table(t.sqliteDef.name, columns, t.options)
-      })
-      return makeSchema({ tables })
-    },
-  },
-)

package/src/util.ts

@@ -1,11 +1,19 @@
 /// <reference lib="es2022" />
 
 import type { Brand } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
 
 export type ParamsObject = Record<string, SqlValue>
 export type SqlValue = string | number | Uint8Array | null
 
-export type Bindable = SqlValue[] | ParamsObject
+export type Bindable = ReadonlyArray<SqlValue> | ParamsObject
+
+export const SqlValueSchema = Schema.Union(Schema.String, Schema.Number, Schema.Uint8Array, Schema.Null)
+
+export const PreparedBindValues = Schema.Union(
+  Schema.Array(SqlValueSchema),
+  Schema.Record(Schema.String, SqlValueSchema),
+).pipe(Schema.brand('PreparedBindValues'))
 
 export type PreparedBindValues = Brand.Branded<Bindable, 'PreparedBindValues'>
 
@@ -33,7 +41,7 @@ export const sql = (template: TemplateStringsArray, ...args: unknown[]): string
 /*  TODO: Search for unused params via proper parsing, not string search
 **/
 export const prepareBindValues = (values: Bindable, statement: string): PreparedBindValues => {
-  if (Array.isArray(values)) return values as PreparedBindValues
+  if (Array.isArray(values)) return values as any as PreparedBindValues
 
   const result: ParamsObject = {}
   for (const [key, value] of Object.entries(values)) {