@livestore/common 0.0.53 → 0.0.54-dev.0

package/src/devtools/index.ts

@@ -0,0 +1,146 @@
+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')

package/src/index.ts

@@ -8,3 +8,4 @@ export * from './rehydrate-from-mutationlog.js'
 export * from './query-info.js'
 export * from './derived-mutations.js'
 export * from './sync/index.js'
+export * as Devtools from './devtools/index.js'

package/src/schema/index.ts

@@ -1,6 +1,7 @@
-import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
+import { isReadonlyArray, pick, shouldNeverHappen } from '@livestore/utils'
 import type { ReadonlyArray } from '@livestore/utils/effect'
-import { SqliteAst, type SqliteDsl } from 'effect-db-schema'
+import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
+import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 import type { MigrationOptions } from '../adapter-types.js'
 import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
@@ -12,7 +13,7 @@ import {
   rawSqlMutation,
 } from './mutations.js'
 import { systemTables } from './system-tables.js'
-import { type TableDef, tableHasDerivedMutations } from './table-def.js'
+import { table, type TableDef, tableHasDerivedMutations } from './table-def.js'
 
 export * from './system-tables.js'
 export * as DbSchema from './table-def.js'
@@ -20,10 +21,14 @@ export * as ParseUtils from './parse-utils.js'
 export * from './mutations.js'
 export * from './schema-helpers.js'
 
+export const LiveStoreSchemaSymbol = Symbol.for('livestore.LiveStoreSchema')
+export type LiveStoreSchemaSymbol = typeof LiveStoreSchemaSymbol
+
 export type LiveStoreSchema<
   TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema,
   TMutationsDefRecord extends MutationDefRecord = MutationDefRecord,
 > = {
+  readonly _Type: LiveStoreSchemaSymbol
   /** Only used on type-level */
   readonly _DbSchemaType: TDbSchema
   /** Only used on type-level */
@@ -99,8 +104,9 @@ export const makeSchema = <TInputSchema extends InputSchema>(
   })
 
   return {
-    _DbSchemaType: Symbol('livestore.DbSchemaType') as any,
-    _MutationDefMapType: Symbol('livestore.MutationDefMapType') as any,
+    _Type: LiveStoreSchemaSymbol,
+    _DbSchemaType: Symbol.for('livestore.DbSchemaType') as any,
+    _MutationDefMapType: Symbol.for('livestore.MutationDefMapType') as any,
     tables,
     mutations,
     migrationOptions: inputSchema.migrations ?? { strategy: 'hard-reset' },
@@ -133,3 +139,65 @@ 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 })
+    },
+  },
+)