@livestore/common 0.4.0-dev.2 → 0.4.0-dev.20

package/src/schema/LiveStoreEvent.ts

@@ -1,287 +0,0 @@
-import { memoizeByRef } from '@livestore/utils'
-import { Option, Schema } from '@livestore/utils/effect'
-
-import type { EventDef, EventDefRecord } from './EventDef.ts'
-import * as EventSequenceNumber from './EventSequenceNumber.ts'
-import type { LiveStoreSchema } from './schema.ts'
-
-export namespace ForEventDef {
-  export type PartialDecoded<TEventDef extends EventDef.Any> = {
-    name: TEventDef['name']
-    args: Schema.Schema.Type<TEventDef['schema']>
-  }
-
-  export type PartialEncoded<TEventDef extends EventDef.Any> = {
-    name: TEventDef['name']
-    args: Schema.Schema.Encoded<TEventDef['schema']>
-  }
-
-  export type Decoded<TEventDef extends EventDef.Any> = {
-    name: TEventDef['name']
-    args: Schema.Schema.Type<TEventDef['schema']>
-    seqNum: EventSequenceNumber.EventSequenceNumber
-    parentSeqNum: EventSequenceNumber.EventSequenceNumber
-    clientId: string
-    sessionId: string
-  }
-
-  export type Encoded<TEventDef extends EventDef.Any> = {
-    name: TEventDef['name']
-    args: Schema.Schema.Encoded<TEventDef['schema']>
-    seqNum: EventSequenceNumber.EventSequenceNumber
-    parentSeqNum: EventSequenceNumber.EventSequenceNumber
-    clientId: string
-    sessionId: string
-  }
-}
-
-export type AnyDecoded = ForEventDef.Decoded<EventDef.Any>
-export const AnyDecoded = Schema.Struct({
-  name: Schema.String,
-  args: Schema.Any,
-  seqNum: EventSequenceNumber.EventSequenceNumber,
-  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
-  clientId: Schema.String,
-  sessionId: Schema.String,
-}).annotations({ title: 'LiveStoreEvent.AnyDecoded' })
-
-export type AnyEncoded = ForEventDef.Encoded<EventDef.Any>
-export const AnyEncoded = Schema.Struct({
-  name: Schema.String,
-  args: Schema.Any,
-  seqNum: EventSequenceNumber.EventSequenceNumber,
-  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
-  clientId: Schema.String,
-  sessionId: Schema.String,
-}).annotations({ title: 'LiveStoreEvent.AnyEncoded' })
-
-export const AnyEncodedGlobal = Schema.Struct({
-  name: Schema.String,
-  args: Schema.Any,
-  seqNum: EventSequenceNumber.GlobalEventSequenceNumber,
-  parentSeqNum: EventSequenceNumber.GlobalEventSequenceNumber,
-  clientId: Schema.String,
-  sessionId: Schema.String,
-}).annotations({ title: 'LiveStoreEvent.AnyEncodedGlobal' })
-export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
-
-export type PartialAnyDecoded = ForEventDef.PartialDecoded<EventDef.Any>
-export type PartialAnyEncoded = ForEventDef.PartialEncoded<EventDef.Any>
-
-export const PartialAnyEncoded = Schema.Struct({
-  name: Schema.String,
-  args: Schema.Any,
-})
-
-export type PartialForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_EventDefMapType']]: ForEventDef.PartialDecoded<TSchema['_EventDefMapType'][K]>
-}[keyof TSchema['_EventDefMapType']]
-
-export type ForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_EventDefMapType']]: ForEventDef.Decoded<TSchema['_EventDefMapType'][K]>
-}[keyof TSchema['_EventDefMapType']]
-
-export const isPartialEventDef = (event: AnyDecoded | PartialAnyDecoded): event is PartialAnyDecoded =>
-  'num' in event === false && 'parentSeqNum' in event === false
-
-export type ForEventDefRecord<TEventDefRecord extends EventDefRecord> = Schema.Schema<
-  {
-    [K in keyof TEventDefRecord]: {
-      name: K
-      args: Schema.Schema.Type<TEventDefRecord[K]['schema']>
-      seqNum: EventSequenceNumber.EventSequenceNumber
-      parentSeqNum: EventSequenceNumber.EventSequenceNumber
-      clientId: string
-      sessionId: string
-    }
-  }[keyof TEventDefRecord],
-  {
-    [K in keyof TEventDefRecord]: {
-      name: K
-      args: Schema.Schema.Encoded<TEventDefRecord[K]['schema']>
-      seqNum: EventSequenceNumber.EventSequenceNumber
-      parentSeqNum: EventSequenceNumber.EventSequenceNumber
-      clientId: string
-      sessionId: string
-    }
-  }[keyof TEventDefRecord]
->
-
-export type EventDefPartialSchema<TEventDefRecord extends EventDefRecord> = Schema.Schema<
-  {
-    [K in keyof TEventDefRecord]: {
-      name: K
-      args: Schema.Schema.Type<TEventDefRecord[K]['schema']>
-    }
-  }[keyof TEventDefRecord],
-  {
-    [K in keyof TEventDefRecord]: {
-      name: K
-      args: Schema.Schema.Encoded<TEventDefRecord[K]['schema']>
-    }
-  }[keyof TEventDefRecord]
->
-
-export const makeEventDefSchema = <TSchema extends LiveStoreSchema>(
-  schema: TSchema,
-): ForEventDefRecord<TSchema['_EventDefMapType']> =>
-  Schema.Union(
-    ...[...schema.eventsDefsMap.values()].map((def) =>
-      Schema.Struct({
-        name: Schema.Literal(def.name),
-        args: def.schema,
-        seqNum: EventSequenceNumber.EventSequenceNumber,
-        parentSeqNum: EventSequenceNumber.EventSequenceNumber,
-        clientId: Schema.String,
-        sessionId: Schema.String,
-      }),
-    ),
-  ).annotations({ title: 'EventDef' }) as any
-
-export const makeEventDefPartialSchema = <TSchema extends LiveStoreSchema>(
-  schema: TSchema,
-): EventDefPartialSchema<TSchema['_EventDefMapType']> =>
-  Schema.Union(
-    ...[...schema.eventsDefsMap.values()].map((def) =>
-      Schema.Struct({
-        name: Schema.Literal(def.name),
-        args: def.schema,
-      }),
-    ),
-  ).annotations({ title: 'EventDefPartial' }) as any
-
-export const makeEventDefSchemaMemo = memoizeByRef(makeEventDefSchema)
-
-export const encodedFromGlobal = (event: AnyEncodedGlobal): AnyEncoded => ({
-  ...event,
-  seqNum: EventSequenceNumber.fromGlobal(event.seqNum),
-  parentSeqNum: EventSequenceNumber.fromGlobal(event.parentSeqNum),
-})
-
-/** Equivalent to AnyEncoded but with a meta field and some convenience methods */
-export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEvent.EncodedWithMeta')({
-  name: Schema.String,
-  args: Schema.Any,
-  seqNum: EventSequenceNumber.EventSequenceNumber,
-  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
-  clientId: Schema.String,
-  sessionId: Schema.String,
-  // TODO get rid of `meta` again by cleaning up the usage implementations
-  meta: Schema.Struct({
-    sessionChangeset: Schema.Union(
-      Schema.TaggedStruct('sessionChangeset', {
-        data: Schema.Uint8Array as any as Schema.Schema<Uint8Array<ArrayBuffer>>,
-        debug: Schema.Any.pipe(Schema.optional),
-      }),
-      Schema.TaggedStruct('no-op', {}),
-      Schema.TaggedStruct('unset', {}),
-    ),
-    syncMetadata: Schema.Option(Schema.JsonValue),
-    /** Used to detect if the materializer is side effecting (during dev) */
-    materializerHashLeader: Schema.Option(Schema.Number),
-    materializerHashSession: Schema.Option(Schema.Number),
-  }).pipe(
-    Schema.mutable,
-    Schema.optional,
-    Schema.withDefaults({
-      constructor: () => ({
-        sessionChangeset: { _tag: 'unset' as const },
-        syncMetadata: Option.none(),
-        materializerHashLeader: Option.none(),
-        materializerHashSession: Option.none(),
-      }),
-      decoding: () => ({
-        sessionChangeset: { _tag: 'unset' as const },
-        syncMetadata: Option.none(),
-        materializerHashLeader: Option.none(),
-        materializerHashSession: Option.none(),
-      }),
-    }),
-  ),
-}) {
-  toJSON = (): any => {
-    // Only used for logging/debugging
-    // - More readable way to print the seqNum + parentSeqNum
-    // - not including `meta`, `clientId`, `sessionId`
-    return {
-      seqNum: `${EventSequenceNumber.toString(this.seqNum)} → ${EventSequenceNumber.toString(this.parentSeqNum)} (${this.clientId}, ${this.sessionId})`,
-      name: this.name,
-      args: this.args,
-    }
-  }
-
-  /**
-   * Example: (global event)
-   * For event e2 → e1 which should be rebased on event e3 → e2
-   * the resulting event num will be e4 → e3
-   *
-   * Example: (client event)
-   * For event e2+1 → e2 which should be rebased on event e3 → e2
-   * the resulting event num will be e3+1 → e3
-   *
-   * Syntax: e2+2 → e2+1
-   *          ^ ^    ^ ^
-   *          | |    | +- client parent number
-   *          | |    +--- global parent number
-   *          | +-- client number
-   *          +---- global number
-   * Client num is ommitted for global events
-   */
-  rebase = ({
-    parentSeqNum,
-    isClient,
-    rebaseGeneration,
-  }: {
-    parentSeqNum: EventSequenceNumber.EventSequenceNumber
-    isClient: boolean
-    rebaseGeneration: number
-  }) =>
-    new EncodedWithMeta({
-      ...this,
-      ...EventSequenceNumber.nextPair({ seqNum: parentSeqNum, isClient, rebaseGeneration }),
-    })
-
-  static fromGlobal = (
-    event: AnyEncodedGlobal,
-    meta: {
-      syncMetadata: Option.Option<Schema.JsonValue>
-      materializerHashLeader: Option.Option<number>
-      materializerHashSession: Option.Option<number>
-    },
-  ) =>
-    new EncodedWithMeta({
-      ...event,
-      seqNum: {
-        global: event.seqNum,
-        client: EventSequenceNumber.clientDefault,
-        rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
-      },
-      parentSeqNum: {
-        global: event.parentSeqNum,
-        client: EventSequenceNumber.clientDefault,
-        rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
-      },
-      meta: {
-        sessionChangeset: { _tag: 'unset' as const },
-        syncMetadata: meta.syncMetadata,
-        materializerHashLeader: meta.materializerHashLeader,
-        materializerHashSession: meta.materializerHashSession,
-      },
-    })
-
-  toGlobal = (): AnyEncodedGlobal => ({
-    ...this,
-    seqNum: this.seqNum.global,
-    parentSeqNum: this.parentSeqNum.global,
-  })
-}
-
-/** NOTE `meta` is not considered for equality */
-export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>
-  a.seqNum.global === b.seqNum.global &&
-  a.seqNum.client === b.seqNum.client &&
-  a.name === b.name &&
-  a.clientId === b.clientId &&
-  a.sessionId === b.sessionId &&
-  // TODO use schema equality here
-  JSON.stringify(a.args) === JSON.stringify(b.args)

package/src/schema/state/sqlite/system-tables.ts

@@ -1,104 +0,0 @@
-import { Schema } from '@livestore/utils/effect'
-
-import * as EventSequenceNumber from '../../EventSequenceNumber.ts'
-import { SqliteDsl } from './db-schema/mod.ts'
-import { table } from './table-def.ts'
-
-/// State DB
-
-export const SCHEMA_META_TABLE = '__livestore_schema'
-
-export const schemaMetaTable = table({
-  name: SCHEMA_META_TABLE,
-  columns: {
-    tableName: SqliteDsl.text({ primaryKey: true }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
-    /** ISO date format */
-    updatedAt: SqliteDsl.text({ nullable: false }),
-  },
-})
-
-export type SchemaMetaRow = typeof schemaMetaTable.Type
-
-export const SCHEMA_EVENT_DEFS_META_TABLE = '__livestore_schema_event_defs'
-
-export const schemaEventDefsMetaTable = table({
-  name: SCHEMA_EVENT_DEFS_META_TABLE,
-  columns: {
-    eventName: SqliteDsl.text({ primaryKey: true }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
-    /** ISO date format */
-    updatedAt: SqliteDsl.text({ nullable: false }),
-  },
-})
-
-export type SchemaEventDefsMetaRow = typeof schemaEventDefsMetaTable.Type
-
-/**
- * Table which stores SQLite changeset blobs which is used for rolling back
- * read-model state during rebasing.
- */
-export const SESSION_CHANGESET_META_TABLE = '__livestore_session_changeset'
-
-export const sessionChangesetMetaTable = table({
-  name: SESSION_CHANGESET_META_TABLE,
-  columns: {
-    // TODO bring back primary key
-    seqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
-    seqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
-    seqNumRebaseGeneration: SqliteDsl.integer({}),
-    changeset: SqliteDsl.blob({ nullable: true }),
-    debug: SqliteDsl.json({ nullable: true }),
-  },
-  indexes: [{ columns: ['seqNumGlobal', 'seqNumClient'], name: 'idx_session_changeset_id' }],
-})
-
-export type SessionChangesetMetaRow = typeof sessionChangesetMetaTable.Type
-
-export const stateSystemTables = [schemaMetaTable, schemaEventDefsMetaTable, sessionChangesetMetaTable] as const
-
-export const isStateSystemTable = (tableName: string) => stateSystemTables.some((_) => _.sqliteDef.name === tableName)
-
-/// Eventlog DB
-
-export const EVENTLOG_META_TABLE = 'eventlog'
-
-export const eventlogMetaTable = table({
-  name: EVENTLOG_META_TABLE,
-  columns: {
-    // TODO Adjust modeling so a global event never needs a client id component
-    seqNumGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.GlobalEventSequenceNumber }),
-    seqNumClient: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.ClientEventSequenceNumber }),
-    seqNumRebaseGeneration: SqliteDsl.integer({ primaryKey: true }),
-    parentSeqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
-    parentSeqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
-    parentSeqNumRebaseGeneration: SqliteDsl.integer({}),
-    /** Event definition name */
-    name: SqliteDsl.text({}),
-    argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
-    clientId: SqliteDsl.text({}),
-    sessionId: SqliteDsl.text({}),
-    schemaHash: SqliteDsl.integer({}),
-    syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
-  },
-  indexes: [
-    { columns: ['seqNumGlobal'], name: 'idx_eventlog_seqNumGlobal' },
-    { columns: ['seqNumGlobal', 'seqNumClient', 'seqNumRebaseGeneration'], name: 'idx_eventlog_seqNum' },
-  ],
-})
-
-export type EventlogMetaRow = typeof eventlogMetaTable.Type
-
-export const SYNC_STATUS_TABLE = '__livestore_sync_status'
-
-// TODO support sync backend identity (to detect if sync backend changes)
-export const syncStatusTable = table({
-  name: SYNC_STATUS_TABLE,
-  columns: {
-    head: SqliteDsl.integer({ primaryKey: true }),
-  },
-})
-
-export type SyncStatusRow = typeof syncStatusTable.Type
-
-export const eventlogSystemTables = [eventlogMetaTable, syncStatusTable] as const

package/src/sync/next/ambient.d.ts

@@ -1,3 +0,0 @@
-declare module 'graphology' {
-  export * from 'graphology-types'
-}

package/src/sync/next/graphology.ts

@@ -1,41 +0,0 @@
-// TODO re-enable when `graphology` supports ESM `exports` and `.js` import/export syntax
-// import {} from 'graphology'
-import * as graphology_ from 'graphology'
-import type * as graphologyTypes from 'graphology-types'
-
-export const graphology = graphology_ as any
-
-export declare class IGraph<
-  NodeAttributes extends graphologyTypes.Attributes = graphologyTypes.Attributes,
-  EdgeAttributes extends graphologyTypes.Attributes = graphologyTypes.Attributes,
-  GraphAttributes extends graphologyTypes.Attributes = graphologyTypes.Attributes,
-> extends graphologyTypes.AbstractGraph<NodeAttributes, EdgeAttributes, GraphAttributes> {
-  constructor(options?: graphologyTypes.GraphOptions)
-}
-
-export const DirectedGraph = class DirectedGraph extends graphology.DirectedGraph {} as typeof IGraph
-
-export const Graph = class Graph extends graphology.Graph {} as typeof IGraph
-
-// export const graphology = graphology_ as graphologyTypes
-
-/*
-
-Example usage:
-
-const dag = new graphology.DirectedGraph({ allowSelfLoops: false })
-
-nodes.forEach((node) => dag.addNode(node.id, { width: node.data.label.length * 100, height: 40 }))
-edges.forEach((edge) => {
-	// TODO do this filtering earlier
-	if (!nodeIds.has(edge.source) || !nodeIds.has(edge.target)) return
-
-	dag.addEdge(edge.source, edge.target)
-})
-
-graphologyLayout.random.assign(dag) // needed for initial `x`, `y` values
-const sensibleSettings = forceAtlas2.inferSettings(dag)
-// forceAtlas2.assign(dag, { iterations: 100, settings: { adjustSizes: true,  } })
-forceAtlas2.assign(dag, { iterations: 100, settings: sensibleSettings })
-
-*/

package/src/sync/next/graphology_.ts

@@ -1,2 +0,0 @@
-export { default as graphologyDag } from 'graphology-dag'
-export * as graphology from './graphology.ts'