@livestore/common 0.3.0-dev.9 → 0.3.1-dev.0

package/src/schema/MutationEvent.ts

@@ -1,185 +0,0 @@
-import { memoizeByRef } from '@livestore/utils'
-import type { Deferred } from '@livestore/utils/effect'
-import { Schema } from '@livestore/utils/effect'
-
-import type { InvalidPushError } from '../sync/sync.js'
-import * as EventId from './EventId.js'
-import type { MutationDef, MutationDefRecord } from './mutations.js'
-import type { LiveStoreSchema } from './schema.js'
-
-export type MutationEventPartial<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Type<TMutationsDef['schema']>
-}
-
-export type MutationEventPartialEncoded<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Encoded<TMutationsDef['schema']>
-}
-
-export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Type<TMutationsDef['schema']>
-  id: EventId.EventId
-  parentId: EventId.EventId
-}
-
-export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Encoded<TMutationsDef['schema']>
-  id: EventId.EventId
-  parentId: EventId.EventId
-}
-
-export type AnyDecoded = MutationEvent<MutationDef.Any>
-export const AnyDecoded = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-}).annotations({ title: 'MutationEvent.AnyDecoded' })
-
-export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
-export const AnyEncoded = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-}).annotations({ title: 'MutationEvent.AnyEncoded' })
-
-export const AnyEncodedGlobal = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.GlobalEventId,
-  parentId: EventId.GlobalEventId,
-}).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
-export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
-
-export type PartialAnyDecoded = MutationEventPartial<MutationDef.Any>
-export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
-
-export type PartialForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_MutationDefMapType']]: MutationEventPartial<TSchema['_MutationDefMapType'][K]>
-}[keyof TSchema['_MutationDefMapType']]
-
-export type ForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
-}[keyof TSchema['_MutationDefMapType']]
-
-export const isPartialMutationEvent = (
-  mutationEvent: AnyDecoded | PartialAnyDecoded,
-): mutationEvent is PartialAnyDecoded => 'id' in mutationEvent === false && 'parentId' in mutationEvent === false
-
-export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
-      id: EventId.EventId
-      parentId: EventId.EventId
-    }
-  }[keyof TMutationsDefRecord],
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
-      id: EventId.EventId
-      parentId: EventId.EventId
-    }
-  }[keyof TMutationsDefRecord]
->
-
-export type MutationEventPartialSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
-    }
-  }[keyof TMutationsDefRecord],
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
-    }
-  }[keyof TMutationsDefRecord]
->
-
-export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
-  schema: TSchema,
-): ForMutationDefRecord<TSchema['_MutationDefMapType']> =>
-  Schema.Union(
-    ...[...schema.mutations.values()].map((def) =>
-      Schema.Struct({
-        mutation: Schema.Literal(def.name),
-        args: def.schema,
-        id: EventId.EventId,
-        parentId: EventId.EventId,
-      }),
-    ),
-  ).annotations({ title: 'MutationEvent' }) as any
-
-export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
-  schema: TSchema,
-): MutationEventPartialSchema<TSchema['_MutationDefMapType']> =>
-  Schema.Union(
-    ...[...schema.mutations.values()].map((def) =>
-      Schema.Struct({
-        mutation: Schema.Literal(def.name),
-        args: def.schema,
-      }),
-    ),
-  ).annotations({ title: 'MutationEventPartial' }) as any
-
-export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
-
-/** Equivalent to AnyEncoded but with a meta field and some convenience methods */
-export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEvent.EncodedWithMeta')({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-  meta: Schema.optionalWith(
-    Schema.Any as Schema.Schema<{
-      deferred?: Deferred.Deferred<void, InvalidPushError>
-      sessionChangeset?: Uint8Array
-    }>,
-    { default: () => ({}) },
-  ),
-}) {
-  toJSON = (): any => {
-    // Only used for logging/debugging
-    // - More readable way to print the id + parentId
-    // - not including `meta`
-    return {
-      id: `(${this.id.global},${this.id.local}) → (${this.parentId.global},${this.parentId.local})`,
-      mutation: this.mutation,
-      args: this.args,
-    }
-  }
-
-  rebase = (parentId: EventId.EventId, isLocal: boolean) =>
-    new EncodedWithMeta({
-      ...this,
-      ...EventId.nextPair(parentId, isLocal),
-    })
-
-  static fromGlobal = (mutationEvent: AnyEncodedGlobal) =>
-    new EncodedWithMeta({
-      ...mutationEvent,
-      id: { global: mutationEvent.id, local: EventId.localDefault },
-      parentId: { global: mutationEvent.parentId, local: EventId.localDefault },
-    })
-
-  toGlobal = (): AnyEncodedGlobal => ({
-    ...this,
-    id: this.id.global,
-    parentId: this.parentId.global,
-  })
-}
-
-export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>
-  a.id.global === b.id.global &&
-  a.id.local === b.id.local &&
-  a.mutation === b.mutation &&
-  // TODO use schema equality here
-  JSON.stringify(a.args) === JSON.stringify(b.args)

package/src/schema/mutations.ts

@@ -1,192 +0,0 @@
-import { Schema } from '@livestore/utils/effect'
-
-import type { BindValues } from '../sql-queries/sql-queries.js'
-import type * as EventId from './EventId.js'
-
-export type MutationDefMap = Map<string | 'livestore.RawSql', MutationDef.Any>
-export type MutationDefRecord = {
-  'livestore.RawSql': RawSqlMutation
-  [name: string]: MutationDef.Any
-}
-
-export type InternalMutationSchema<TRecord extends MutationDefRecord = MutationDefRecord> = {
-  _DefRecord: TRecord
-
-  map: Map<keyof TRecord, TRecord[keyof TRecord]>
-  schemaHashMap: Map<keyof TRecord, number>
-}
-
-export type MutationDefSqlResult<TTo> =
-  | SingleOrReadonlyArray<string>
-  | ((args: TTo) => SingleOrReadonlyArray<
-      | string
-      | {
-          sql: string
-          /** Note args need to be manually encoded to `BindValues` when returning this argument */
-          bindValues: BindValues
-          writeTables?: ReadonlySet<string>
-        }
-    >)
-
-export type SingleOrReadonlyArray<T> = T | ReadonlyArray<T>
-
-export type MutationDef<TName extends string, TFrom, TTo> = {
-  name: TName
-  schema: Schema.Schema<TTo, TFrom>
-  sql: MutationDefSqlResult<NoInfer<TTo>>
-  options: {
-    /** Warning: This feature is not fully implemented yet */
-    historyId: string
-    /**
-     * When set to true, the mutation won't be synced over the network
-     */
-    localOnly: boolean
-    /** Warning: This feature is not fully implemented yet */
-    facts: FactsCallback<TTo> | undefined
-  }
-
-  /** Helper function to construct a partial mutation event */
-  (
-    args: TTo,
-    options?: {
-      id?: number
-    },
-  ): {
-    mutation: TName
-    args: TTo
-    // TODO remove/clean up after sync-next is fully implemented
-    id?: EventId.EventId
-  }
-}
-
-export type FactsCallback<TTo> = (
-  args: TTo,
-  currentFacts: MutationEventFacts,
-) => {
-  modify: {
-    set: Iterable<MutationEventFactInput>
-    unset: Iterable<MutationEventFactInput>
-  }
-  require: Iterable<MutationEventFactInput>
-}
-
-export namespace MutationDef {
-  export type Any = MutationDef<string, any, any>
-}
-
-export type MutationEventKey = string
-export type MutationEventFact = string
-export type MutationEventFacts = ReadonlyMap<string, any>
-
-export type MutationEventFactsGroup = {
-  modifySet: MutationEventFacts
-  modifyUnset: MutationEventFacts
-
-  /**
-   * Events on independent "dependency" branches are commutative which can facilitate more prioritized syncing
-   */
-  depRequire: MutationEventFacts
-  depRead: MutationEventFacts
-}
-
-export type MutationEventFactsSnapshot = Map<string, any>
-
-export type MutationEventFactInput = string | readonly [string, any]
-
-export const defineFacts = <
-  TRecord extends Record<string, MutationEventFactInput | ((...args: any[]) => MutationEventFactInput)>,
->(
-  record: TRecord,
-): TRecord => record
-
-export type DefineMutationOptions<TTo> = {
-  // TODO actually implement this
-  onError?: (error: any) => void
-  historyId?: string
-  /** Warning: This feature is not fully implemented yet */
-  facts?: (
-    args: TTo,
-    currentFacts: MutationEventFacts,
-  ) => {
-    modify?: {
-      set?: Iterable<MutationEventFactInput>
-      unset?: Iterable<MutationEventFactInput>
-    }
-    /**
-     * Two purposes: constrain history and constrain compaction
-     */
-    require?: Iterable<MutationEventFactInput>
-  }
-  /**
-   * When set to true, the mutation won't be synced over the network
-   */
-  localOnly?: boolean
-}
-
-// TODO possibly also allow for mutation event subsumption behaviour
-export const defineMutation = <TName extends string, TFrom, TTo>(
-  name: TName,
-  schema: Schema.Schema<TTo, TFrom>,
-  sql: MutationDefSqlResult<NoInfer<TTo>>,
-  options?: DefineMutationOptions<TTo>,
-): MutationDef<TName, TFrom, TTo> => {
-  const makePartialEvent = (
-    args: TTo,
-    options?: {
-      id?: EventId.EventId
-    },
-  ) => ({ mutation: name, args, ...options })
-
-  Object.defineProperty(makePartialEvent, 'name', { value: name })
-  Object.defineProperty(makePartialEvent, 'schema', { value: schema })
-  Object.defineProperty(makePartialEvent, 'sql', { value: sql })
-  Object.defineProperty(makePartialEvent, 'options', {
-    value: {
-      historyId: options?.historyId ?? 'main',
-      localOnly: options?.localOnly ?? false,
-      facts: options?.facts
-        ? (args, currentFacts) => {
-            const res = options.facts!(args, currentFacts)
-            return {
-              modify: {
-                set: res.modify?.set ? new Set(res.modify.set) : new Set(),
-                unset: res.modify?.unset ? new Set(res.modify.unset) : new Set(),
-              },
-              require: res.require ? new Set(res.require) : new Set(),
-            }
-          }
-        : undefined,
-    } satisfies MutationDef.Any['options'],
-  })
-
-  return makePartialEvent as MutationDef<TName, TFrom, TTo>
-}
-
-export const makeMutationDefRecord = <TInputRecord extends Record<string, MutationDef.Any>>(
-  inputRecord: TInputRecord,
-): {
-  [K in TInputRecord[keyof TInputRecord]['name']]: Extract<TInputRecord[keyof TInputRecord], { name: K }>
-} => {
-  const result: any = {}
-
-  for (const [name, def] of Object.entries(inputRecord)) {
-    result[name] = def
-  }
-
-  result['livestore.RawSql'] = rawSqlMutation
-
-  return result
-}
-
-export const rawSqlMutation = defineMutation(
-  'livestore.RawSql',
-  Schema.Struct({
-    sql: Schema.String,
-    bindValues: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-    writeTables: Schema.optional(Schema.ReadonlySet(Schema.String)),
-  }),
-  ({ sql, bindValues, writeTables }) => ({ sql, bindValues: bindValues ?? {}, writeTables }),
-)
-
-export type RawSqlMutation = typeof rawSqlMutation
-export type RawSqlMutationEvent = ReturnType<typeof rawSqlMutation>

package/src/schema/system-tables.ts

@@ -1,105 +0,0 @@
-import { type SqliteAst as __SqliteAst, SqliteDsl } from '@livestore/db-schema'
-import { Schema } from '@livestore/utils/effect'
-
-import * as EventId from './EventId.js'
-import type { FromTable } from './table-def.js'
-import { table } from './table-def.js'
-
-/// App DB
-
-export const SCHEMA_META_TABLE = '__livestore_schema'
-
-export const schemaMetaTable = table(
-  SCHEMA_META_TABLE,
-  {
-    tableName: SqliteDsl.text({ primaryKey: true }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
-    /** ISO date format */
-    updatedAt: SqliteDsl.text({ nullable: false }),
-  },
-  { disableAutomaticIdColumn: true },
-)
-
-export type SchemaMetaRow = FromTable.RowDecoded<typeof schemaMetaTable>
-
-export const SCHEMA_MUTATIONS_META_TABLE = '__livestore_schema_mutations'
-
-export const schemaMutationsMetaTable = table(
-  SCHEMA_MUTATIONS_META_TABLE,
-  {
-    mutationName: SqliteDsl.text({ primaryKey: true }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
-    /** ISO date format */
-    updatedAt: SqliteDsl.text({ nullable: false }),
-  },
-  { disableAutomaticIdColumn: true },
-)
-
-export type SchemaMutationsMetaRow = FromTable.RowDecoded<typeof schemaMutationsMetaTable>
-
-/**
- * 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(
-  SESSION_CHANGESET_META_TABLE,
-  {
-    // TODO bring back primary key
-    idGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
-    idLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
-    changeset: SqliteDsl.blob({ nullable: true }),
-    debug: SqliteDsl.json({ nullable: true }),
-  },
-  {
-    disableAutomaticIdColumn: true,
-    indexes: [{ columns: ['idGlobal', 'idLocal'], name: 'idx_session_changeset_id' }],
-  },
-)
-
-export type SessionChangesetMetaRow = FromTable.RowDecoded<typeof sessionChangesetMetaTable>
-
-export const systemTables = [schemaMetaTable, schemaMutationsMetaTable, sessionChangesetMetaTable]
-
-/// Mutation log DB
-
-export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'localOnly')
-export type SyncStatus = typeof SyncStatus.Type
-
-export const MUTATION_LOG_META_TABLE = 'mutation_log'
-
-export const mutationLogMetaTable = table(
-  MUTATION_LOG_META_TABLE,
-  {
-    idGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventId.GlobalEventId }),
-    idLocal: SqliteDsl.integer({ primaryKey: true, schema: EventId.LocalEventId }),
-    parentIdGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
-    parentIdLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
-    mutation: SqliteDsl.text({}),
-    argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
-    schemaHash: SqliteDsl.integer({}),
-    syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
-  },
-  {
-    disableAutomaticIdColumn: true,
-    indexes: [
-      { columns: ['idGlobal'], name: 'idx_idGlobal' },
-      { columns: ['idGlobal', 'idLocal'], name: 'idx_mutationlog_id' },
-    ],
-  },
-)
-
-export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>
-
-export const SYNC_STATUS_TABLE = '__livestore_sync_status'
-
-export const syncStatusTable = table(
-  SYNC_STATUS_TABLE,
-  {
-    head: SqliteDsl.integer({ primaryKey: true }),
-  },
-  { disableAutomaticIdColumn: true },
-)
-
-export type SyncStatusRow = FromTable.RowDecoded<typeof syncStatusTable>