@livestore/common 0.0.58-dev.9 → 0.1.0-dev.2

package/src/adapter-types.ts

@@ -12,7 +12,7 @@ export interface PreparedStatement {
   sql: string
 }
 
-export type StoreAdapter = {
+export type ClientSession = {
   /** SQLite database with synchronous API running in the same thread (usually in-memory) */
   syncDb: SynchronousDatabase
   /** The coordinator is responsible for persisting the database, syncing etc */
@@ -62,8 +62,10 @@ export type BootStatus = typeof BootStatus.Type
 export type Coordinator = {
   devtools: {
     enabled: boolean
+    // TODO incorporate sessionId and rethink appHostId
     appHostId: string
   }
+  sessionId: string
   // TODO is exposing the lock status really needed (or only relevant for web adapter?)
   lockStatus: SubscriptionRef.SubscriptionRef<LockStatus>
   syncMutations: Stream.Stream<MutationEvent.Any, UnexpectedError>
@@ -73,7 +75,7 @@ export type Coordinator = {
     options: { persisted: boolean },
   ): Effect.Effect<void, UnexpectedError>
   /** Can be called synchronously */
-  getNextMutationEventId: (opts: { localOnly: boolean }) => Effect.Effect<EventId, UnexpectedError>
+  nextMutationEventIdPair: (opts: { localOnly: boolean }) => Effect.Effect<EventIdPair, UnexpectedError>
   /** Used to initially get the current mutation event id to use as `parentId` for the next mutation event */
   getCurrentMutationEventId: Effect.Effect<EventId, UnexpectedError>
   export: Effect.Effect<Uint8Array | undefined, UnexpectedError>
@@ -81,6 +83,18 @@ export type Coordinator = {
   networkStatus: SubscriptionRef.SubscriptionRef<NetworkStatus>
 }
 
+/**
+ * Can be used in queries to refer to the current session id.
+ * Will be replaced with the actual session id at runtime
+ *
+ * Example:
+ * ```ts
+ * const query$ = rowQuery(tables.app, SessionIdSymbol)
+ * ```
+ */
+export const SessionIdSymbol = Symbol.for('@livestore/session-id')
+export type SessionIdSymbol = typeof SessionIdSymbol
+
 export type LockStatus = 'has-lock' | 'no-lock'
 
 /**
@@ -96,15 +110,9 @@ export const EventId = Schema.Struct({
   local: Schema.Number,
 }).annotations({ title: 'LiveStore.EventId' })
 
-export const ROOT_ID = { global: -1, local: 0 } satisfies EventId
+export type EventIdPair = { id: EventId; parentId: EventId }
 
-export type BootDb = {
-  _tag: 'BootDb'
-  execute(queryStr: string, bindValues?: PreparedBindValues): void
-  mutate: <const TMutationArg extends ReadonlyArray<MutationEvent.PartialAny>>(...list: TMutationArg) => void
-  select<T>(queryStr: string, bindValues?: PreparedBindValues): ReadonlyArray<T>
-  txn(callback: () => void): void
-}
+export const ROOT_ID = { global: -1, local: 0 } satisfies EventId
 
 export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('LiveStore.UnexpectedError', {
   cause: Schema.Defect,
@@ -190,11 +198,11 @@ export type ConnectDevtoolsToStore = (
   storeDevtoolsChannel: StoreDevtoolsChannel,
 ) => Effect.Effect<void, UnexpectedError, Scope.Scope>
 
-export type StoreAdapterFactory = (opts: {
+export type Adapter = (opts: {
   schema: LiveStoreSchema
   storeId: string
   devtoolsEnabled: boolean
   bootStatusQueue: Queue.Queue<BootStatus>
   shutdown: (cause: Cause.Cause<any>) => Effect.Effect<void>
   connectDevtoolsToStore: ConnectDevtoolsToStore
-}) => Effect.Effect<StoreAdapter, UnexpectedError, Scope.Scope>
+}) => Effect.Effect<ClientSession, UnexpectedError, Scope.Scope>

package/src/bounded-collections.ts

@@ -16,7 +16,7 @@ export class BoundMap<K, V> {
     this.#map.set(key, value)
     // console.log(this.#map.size, this.#sizeLimit);
     if (this.#map.size > this.#sizeLimit) {
-      const firstKey = this.#map.keys().next().value
+      const firstKey = this.#map.keys().next().value as K
       const deletedValue = this.#map.get(firstKey)!
       this.#map.delete(firstKey)
       if (this.onEvict) {

package/src/derived-mutations.ts

@@ -1,6 +1,6 @@
+import type { SqliteDsl } from '@livestore/db-schema'
 import type { GetValForKey } from '@livestore/utils'
 import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
-import type { SqliteDsl } from 'effect-db-schema'
 
 import type { MutationEvent } from './schema/mutations.js'
 import { defineMutation } from './schema/mutations.js'
@@ -38,9 +38,9 @@ export const deriveCreateMutationDef = <
     (col) => col.nullable === false && col.default._tag === 'None',
   )
 
-  const insertSchema = Schema.Struct(ReadonlyRecord.map(requiredColumns, (col) => col.schema)).pipe(
-    Schema.extend(Schema.partial(Schema.Struct(ReadonlyRecord.map(optionalFields, (col) => col.schema)))),
-  )
+  const insertSchema = Schema.Struct(ReadonlyRecord.map(requiredColumns, (col) => col.schema))
+    .pipe(Schema.extend(Schema.partial(Schema.Struct(ReadonlyRecord.map(optionalFields, (col) => col.schema)))))
+    .annotations({ title: `${tableName}:Insert` })
 
   return defineMutation(
     `_Derived_Create_${tableName}`,
@@ -76,7 +76,7 @@ export const deriveUpdateMutationDef = <
     Schema.Struct({
       where: Schema.partial(table.schema),
       values: Schema.partial(table.schema),
-    }),
+    }).annotations({ title: `${tableName}:Update` }),
     ({ where, values }) => {
       const [sql, bindValues] = updateRows({
         tableName: table.sqliteDef.name,

package/src/devtools/devtools-messages.ts

@@ -101,7 +101,7 @@ export class LiveQueriesSubscribe extends LSDReqResMessage('LSD.LiveQueriesSubsc
 export class LiveQueriesUnsubscribe extends LSDReqResMessage('LSD.LiveQueriesUnsubscribe', {}) {}
 
 export class SerializedLiveQuery extends Schema.Struct({
-  _tag: Schema.Literal('js', 'sql', 'graphql'),
+  _tag: Schema.Literal('computed', 'sql', 'graphql'),
   id: Schema.Number,
   label: Schema.String,
   runs: Schema.Number,

package/src/index.ts

@@ -1,6 +1,7 @@
 export * from './schema/system-tables.js'
 export * from './util.js'
 export * from './adapter-types.js'
+export * from './sync/next-mutation-event-id-pair.js'
 export * from './schema-management/migrations.js'
 export * from './mutation.js'
 export * from './init-singleton-tables.js'

package/src/mutation.ts

@@ -1,6 +1,7 @@
 import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
 import { Schema } from '@livestore/utils/effect'
 
+import { SessionIdSymbol } from './adapter-types.js'
 import type { LiveStoreSchema } from './schema/index.js'
 import type { MutationDef, MutationEvent } from './schema/mutations.js'
 import type { PreparedBindValues } from './util.js'
@@ -67,3 +68,25 @@ export const makeShouldExcludeMutationFromLog = memoizeByRef((schema: LiveStoreS
     return execArgsArr.some((_) => _.statementSql.includes('__livestore'))
   }
 })
+
+// NOTE we should explore whether there is a more elegant solution
+// e.g. by leveraging the schema to replace the sessionIdSymbol
+export const replaceSessionIdSymbol = (bindValues: Record<string, unknown>, sessionId: string) => {
+  deepReplaceValue(bindValues, SessionIdSymbol, sessionId)
+}
+
+const deepReplaceValue = <S, R>(input: any, searchValue: S, replaceValue: R): void => {
+  if (Array.isArray(input)) {
+    for (const i in input) {
+      deepReplaceValue(input[i], searchValue, replaceValue)
+    }
+  } else if (typeof input === 'object' && input !== null) {
+    for (const key in input) {
+      if (input[key] === searchValue) {
+        input[key] = replaceValue
+      } else {
+        deepReplaceValue(input[key], searchValue, replaceValue)
+      }
+    }
+  }
+}

package/src/query-info.ts

@@ -1,5 +1,6 @@
 import type { Schema } from '@livestore/utils/effect'
 
+import type { SessionIdSymbol } from './adapter-types.js'
 import type { DbSchema } from './schema/index.js'
 
 /**
@@ -21,7 +22,7 @@ export type QueryInfoNone = {
 export type QueryInfoRow<TTableDef extends DbSchema.TableDef> = {
   _tag: 'Row'
   table: TTableDef
-  id: string
+  id: string | SessionIdSymbol
 }
 
 export type QueryInfoCol<
@@ -30,14 +31,14 @@ export type QueryInfoCol<
 > = {
   _tag: 'Col'
   table: TTableDef
-  id: string
+  id: string | SessionIdSymbol
   column: TColName
 }
 
 export type QueryInfoColJsonValue<TTableDef extends DbSchema.TableDef, TColName extends GetJsonColumn<TTableDef>> = {
   _tag: 'ColJsonValue'
   table: TTableDef
-  id: string
+  id: string | SessionIdSymbol
   column: TColName
   /**
    * example: `$.tabs[3].items[2]` (`$` referring to the column value)

package/src/schema/index.ts

@@ -1,6 +1,6 @@
+import type { SqliteDsl } from '@livestore/db-schema'
+import { SqliteAst } from '@livestore/db-schema'
 import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
-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'
@@ -46,6 +46,7 @@ export type InputSchema = {
   /**
    * Can be used to isolate multiple LiveStore apps running in the same origin
    */
+  // TODO remove this in favour of storeId
   readonly key?: string
 }
 
@@ -116,7 +117,7 @@ export const makeSchema = <TInputSchema extends InputSchema>(
   } satisfies LiveStoreSchema
 }
 
-namespace FromInputSchema {
+export namespace FromInputSchema {
   export type DeriveSchema<TInputSchema extends InputSchema> = LiveStoreSchema<
     DbSchemaFromInputSchemaTables<TInputSchema['tables']>,
     MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>

package/src/schema/mutations.ts

@@ -231,6 +231,10 @@ export namespace MutationEvent {
   }[keyof TSchema['_MutationDefMapType']]
 }
 
+export const isPartialMutationEvent = (
+  mutationEvent: MutationEvent.Any | MutationEvent.PartialAny,
+): mutationEvent is MutationEvent.PartialAny => 'id' in mutationEvent === false && 'parentId' in mutationEvent === false
+
 export type MutationEventSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
   {
     [K in keyof TMutationsDefRecord]: {

package/src/schema/schema-helpers.ts

@@ -1,6 +1,6 @@
+import { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
-import { SqliteDsl } from 'effect-db-schema'
 
 import type { TableDef } from './table-def.js'
 

package/src/schema/system-tables.ts

@@ -1,5 +1,5 @@
+import { type SqliteAst as __SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { Schema } from '@livestore/utils/effect'
-import { type SqliteAst as __SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 import type { FromTable } from './table-def.js'
 import { table } from './table-def.js'
@@ -73,14 +73,12 @@ export const mutationLogMetaTable = table(
     mutation: SqliteDsl.text({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
     schemaHash: SqliteDsl.integer({}),
-    /** Local only, used for ordered queries to avoid recursive id traversal */
-    orderKey: SqliteDsl.integer({}),
     /** ISO date format */
     createdAt: SqliteDsl.text({}),
     syncStatus: SqliteDsl.text({ schema: SyncStatus }),
     syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
   },
-  { disableAutomaticIdColumn: true, indexes: [{ columns: ['orderKey'], name: 'mutation_log_order_key_idx' }] },
+  { disableAutomaticIdColumn: true, indexes: [] },
 )
 
 export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>

package/src/schema/table-def.ts

@@ -1,14 +1,14 @@
+import type { Nullable, PrettifyFlat } from '@livestore/db-schema'
+import { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
-import type { Nullable, PrettifyFlat } from 'effect-db-schema'
-import { SqliteDsl } from 'effect-db-schema'
 
 import type { DerivedMutationHelperFns } from '../derived-mutations.js'
 import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
 
 export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
 
-export { type SqliteDsl } from 'effect-db-schema'
+export { type SqliteDsl } from '@livestore/db-schema'
 
 export type StateType = 'singleton' | 'dynamic'
 

package/src/schema-management/migrations.ts

@@ -1,6 +1,6 @@
+import { SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
-import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 import type { SynchronousDatabase } from '../adapter-types.js'
 import type { LiveStoreSchema } from '../schema/index.js'

package/src/sql-queries/sql-queries.ts

@@ -1,6 +1,6 @@
+import type { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyArray, Schema, TreeFormatter } from '@livestore/utils/effect'
-import type { SqliteDsl } from 'effect-db-schema'
 
 import { sql } from '../util.js'
 import { objectEntries } from './misc.js'
@@ -58,15 +58,26 @@ export const insertRow = <TColumns extends SqliteDsl.Columns>({
   values: ClientTypes.DecodedValuesForColumns<TColumns>
   options?: { orReplace: boolean }
 }): [string, BindValues] => {
-  const keysStr = Object.keys(values).join(', ')
-  const valuesStr = Object.keys(values)
-    .map((_) => `$${_}`)
+  const stmt = insertRowPrepared({ tableName, columns, options })
+
+  return [stmt, makeBindValues({ columns, values })]
+}
+
+export const insertRowPrepared = <TColumns extends SqliteDsl.Columns>({
+  tableName,
+  columns,
+  options = { orReplace: false },
+}: {
+  tableName: string
+  columns: TColumns
+  options?: { orReplace: boolean }
+}): string => {
+  const keysStr = Object.keys(columns).join(', ')
+  const valuesStr = Object.keys(columns)
+    .map((key) => `$${key}`)
     .join(', ')
 
-  return [
-    sql`INSERT ${options.orReplace ? 'OR REPLACE ' : ''}INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`,
-    makeBindValues({ columns, values }),
-  ]
+  return sql`INSERT ${options.orReplace ? 'OR REPLACE ' : ''}INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`
 }
 
 export const insertRows = <TColumns extends SqliteDsl.Columns>({
@@ -243,14 +254,14 @@ export const createTable = ({
   return sql`CREATE TABLE ${tableName} (${columnDefStrs.join(', ')});`
 }
 
-export const makeBindValues = <TColumns extends SqliteDsl.Columns, TKeys extends string>({
+export const makeBindValues = <TColumns extends SqliteDsl.Columns, TKeys extends keyof TColumns>({
   columns,
   values,
   variablePrefix = '',
   skipNil,
 }: {
   columns: TColumns
-  values: Record<TKeys, any>
+  values: Partial<Record<TKeys, any>>
   variablePrefix?: string
   /** So far only used to prepare `where` statements */
   skipNil?: boolean

package/src/sql-queries/sql-query-builder.ts

@@ -1,4 +1,4 @@
-import type { SqliteDsl } from 'effect-db-schema'
+import type { SqliteDsl } from '@livestore/db-schema'
 
 import type { BindValues } from './sql-queries.js'
 import * as SqlQueries from './sql-queries.js'

package/src/sql-queries/types.ts

@@ -1,5 +1,5 @@
+import type { Prettify, SqliteDsl } from '@livestore/db-schema'
 import type { Schema } from '@livestore/utils/effect'
-import type { Prettify, SqliteDsl } from 'effect-db-schema'
 
 export type DecodedValuesForTableAll<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = {
   [K in keyof GetColumns<TSchema, TTableName>]: Schema.Schema.Type<GetColumn<TSchema, TTableName, K>['schema']>

package/src/sync/next/facts.ts

@@ -1,4 +1,4 @@
-import { graphologyDag, notYetImplemented } from '@overtone/utils'
+import { notYetImplemented } from '@livestore/utils'
 
 import type { EventId } from '../../adapter-types.js'
 import type {
@@ -8,6 +8,7 @@ import type {
   MutationEventFactsGroup,
   MutationEventFactsSnapshot,
 } from '../../schema/mutations.js'
+import { graphologyDag } from './graphology_.js'
 import { EMPTY_FACT_VALUE, type HistoryDag, type HistoryDagNode } from './history-dag.js'
 
 export const factsSnapshotForEvents = (events: HistoryDagNode[], endEventId: EventId): MutationEventFactsSnapshot => {

package/src/sync/next-mutation-event-id-pair.ts

@@ -0,0 +1,20 @@
+import { Effect } from '@livestore/utils/effect'
+
+import type { EventId } from '../adapter-types.js'
+
+export const makeNextMutationEventIdPair =
+  (currentMutationEventIdRef: { current: EventId }) => (opts: { localOnly: boolean }) =>
+    Effect.gen(function* () {
+      // NOTE we always point to `local: 0` for non-localOnly mutations
+      const parentId = opts.localOnly
+        ? currentMutationEventIdRef.current
+        : { global: currentMutationEventIdRef.current.global, local: 0 }
+
+      const id = opts.localOnly
+        ? { global: parentId.global, local: parentId.local + 1 }
+        : { global: parentId.global + 1, local: 0 }
+
+      currentMutationEventIdRef.current = id
+
+      return { id, parentId }
+    })

package/src/version.ts

@@ -1,3 +1,12 @@
 import packageJson from '../package.json' with { type: 'json' }
 
 export const liveStoreVersion = packageJson.version
+
+/**
+ * This version number is incremented whenever the internal storage format changes in a breaking way.
+ * Whenever this version changes, LiveStore will start with fresh database files. Old database files are not deleted.
+ *
+ * While LiveStore is in alpha, this might happen more frequently.
+ * In the future, LiveStore will provide a migration path for older database files to avoid the impression of data loss.
+ */
+export const liveStoreStorageFormatVersion = 2

package/tsconfig.json

@@ -7,5 +7,5 @@
     "tsBuildInfoFile": "./dist/.tsbuildinfo"
   },
   "include": ["./src"],
-  "references": [{ "path": "../../effect-db-schema" }, { "path": "../utils" }]
+  "references": [{ "path": "../db-schema" }, { "path": "../utils" }]
 }

package/dist/sync/next/mutation-fixtures.d.ts

@@ -1,73 +0,0 @@
-import type { MutationDef } from '@livestore/common/schema';
-import type { EventNode } from './history-dag.js';
-/** Used for conflict detection and event history compaction */
-export declare const facts: {
-    todoExists: (id: string) => string;
-    todoIsWriteable: (id: string, writeable: boolean) => [string, boolean];
-    todoCompleted: (id: string, completed: boolean) => [string, boolean];
-    todoTextUpdated: (id: string) => string;
-    inputValue: (id: string) => string;
-};
-export declare const mutations: {
-    createTodo: MutationDef<"createTodo", {
-        readonly id: string;
-        readonly text: string;
-    }, {
-        readonly id: string;
-        readonly text: string;
-    }>;
-    upsertTodo: MutationDef<"upsertTodo", {
-        readonly id: string;
-        readonly text?: string | undefined;
-    }, {
-        readonly id: string;
-        readonly text?: string | undefined;
-    }>;
-    completeTodo: MutationDef<"completeTodo", {
-        readonly id: string;
-    }, {
-        readonly id: string;
-    }>;
-    uncompleteTodo: MutationDef<"uncompleteTodo", {
-        readonly id: string;
-    }, {
-        readonly id: string;
-    }>;
-    completeTodos: MutationDef<"completeTodos", {
-        readonly ids: readonly string[];
-    }, {
-        readonly ids: readonly string[];
-    }>;
-    toggleTodo: MutationDef<"toggleTodo", {
-        readonly id: string;
-    }, {
-        readonly id: string;
-    }>;
-    setReadonlyTodo: MutationDef<"setReadonlyTodo", {
-        readonly id: string;
-        readonly readonly: boolean;
-    }, {
-        readonly id: string;
-        readonly readonly: boolean;
-    }>;
-    setTextTodo: MutationDef<"setTextTodo", {
-        readonly id: string;
-        readonly text: string;
-    }, {
-        readonly id: string;
-        readonly text: string;
-    }>;
-    setInputValue: MutationDef<"setInputValue", {
-        readonly id: string;
-        readonly text: string;
-    }, {
-        readonly id: string;
-        readonly text: string;
-    }>;
-};
-export type PartialEvent = {
-    mutation: string;
-    args: any;
-};
-export declare const toEventNodes: (partialEvents: PartialEvent[], mutationDefs: Record<string, MutationDef.Any>) => EventNode[];
-//# sourceMappingURL=mutation-fixtures.d.ts.map

package/dist/sync/next/mutation-fixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutation-fixtures.d.ts","sourceRoot":"","sources":["../../../src/sync/next/mutation-fixtures.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAK3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAGjD,+DAA+D;AAC/D,eAAO,MAAM,KAAK;qBACC,MAAM;0BACD,MAAM,aAAa,OAAO;wBAC5B,MAAM,aAAa,OAAO;0BACxB,MAAM;qBACX,MAAM;CACvB,CAAA;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+GrB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAAA;AAE1D,eAAO,MAAM,YAAY,kBACR,YAAY,EAAE,gBACf,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,KAC5C,SAAS,EAkFX,CAAA"}