React.ChannelErrors

Extends unknown.

Show error message to user on subscription errors in components deep in the tree.

import { ChannelErrors } from '@logux/client/react'

export const App: FC = () => {
  return <>
    <SideMenu />
    <ChannelErrors
      NotFound={NotFoundPage}
      AccessDenied={AccessDeniedPage}
      Error={ServerErrorPage}
    >
      <Layout />
    </ChannelErrors>
  <>
}

`React.ErrorsContext`

Context to pass error handlers from ChannelErrors.

Type: ReactContext.

`React.useAuth()`

Hook to return user's current authentication state and ID.

import { useAuth } from '@logux/client/react'

export const UserPage = () => {
  let { isAuthenticated, userId } = useAuth()
  if (isAuthenticated) {
    return <User id={userId} />
  } else {
    return <Loader />
  }
}

Returns StoreValue.

`React.useClient()`

Hook to return Logux client, which you set by <ClientContext.Provider>.

import { useClient } from '@logux/client/react'

import { User } from '../stores/user'

export const NewUserForm = () => {
  let client = useClient()
  let onAdd = data => {
    User.create(client, data)
  }
}

Returns Client.

`React.useFilter(Template, filter?, opts?)`

The way to createFilter in React.

import { useFilter } from '@logux/client/react'

import { User } from '../stores/user'

export const Users = ({ projectId }) => {
  let users = useFilter(User, { projectId })
  return <div>
    {users.list.map(user => <User user={user} />)}
    {users.isLoading && <Loader />}
  </div>
}

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store template.
`filter` ?	`Filter`	Key-value filter for stores.
`opts` ?	`FilterOptions`	Filter options.

Returns StoreValue. Filter store to use with map.

`React.useSync(Template, id)`

Create store by ID, subscribe and get store’s value.

import { useSync } from '@logux/client/react'

import { User } from '../stores/user'

export const UserPage: FC = ({ id }) => {
  let user = useSync(User, id)
  if (user.isLoading) {
    return <Loader />
  } else {
    return <h1>{user.name}</h1>
  }
}

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store builder.
`id`	`string`	Store ID.

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store builder.
`id`	`string`	Store ID.
`args`	`Args`	Other store arguments.

Returns SyncMapValue. Store value.

`Vue.ChannelErrorsSlotProps`

Property	Type
`code`	`Ref<Type>`
`error`	`Ref<Type>`

`Vue.loguxPlugin(app, client)`

Plugin that injects Logux Client into all components within the application.

import { createApp } from 'vue'
import { loguxPlugin } from '@logux/client/vue'
import { CrossTabClient } from '@logux/client'

let client = new CrossTabClient(…)
let app = createApp(…)

app.use(loguxPlugin, client)

Argument	Type
`app`	`App`
`client`	`Client`

`Vue.useAuth(client?)`

Returns user's current authentication state and ID.

<template>
  <user v-if="isAuthenticated" :id="userId" />
  <sign-in v-else />
</template>

<script>
import { useAuth } from '@logux/client/vue'

export default () => {
  let { isAuthenticated, userId } = useAuth()
  return { isAuthenticated, userId }
}
</script>

Argument	Type	Description
`client` ?	`Client`	Logux Client instance.

Returns { isAuthenticated: ComputedRef, userId: ComputedRef }.

`Vue.useClient()`

Returns the Logux Client instance.

<script>
import { useClient } from '@logux/client/vue'

import { User } from '../stores/user'

let client = useClient()
let onAdd = data => {
  User.create(client, data)
}
</script>

Returns Client.

`Vue.useFilter(Template, filter?, opts?)`

The way to createFilter in Vue.

<template>
  <loader v-if="users.isLoading" />
  <user v-else v-for="user in users" :user="user" />
</template>

<script>
import { useFilter } from '@logux/client/vue'

import { User } from '../stores/user'

export default {
  props: ['projectId'],
  setup (props) {
    let users = useFilter(User, { projectId: props.projectId })
    return { users }
  }
}
</script>

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store class.
`filter` ?	`any`	Key-value filter for stores.
`opts` ?	`any`	Filter options.

Returns Ref<Type>. Filter store to use with map.

`Vue.useSync(Template, id)`

Create store by ID, subscribe to store changes and get store’s value.

<template>
  <loader v-if="user.isLoading" />
  <h1 v-else>{{ user.name }}</h1>
</template>

<script>
import { useSync } from '@logux/client/vue'

import { User } from '../stores/user'

export default {
  props: ['id'],
  setup (props) {
    let user = useSync(User, props.id)
    return { user }
  }
}
</script>

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store template.
`id`	`any`	Store ID.

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store template.
`id`	`any`	Store ID.
`args`	`Args`	Other store arguments.

Returns Ref<Type>. Store value.

Preact.ChannelErrors

Extends unknown.

Show error message to user on subscription errors in components deep in the tree.

import { ChannelErrors } from '@logux/client/preact'

export const App: FC = () => {
  return <>
    <SideMenu />
    <ChannelErrors
      NotFound={NotFoundPage}
      AccessDenied={AccessDeniedPage}
      Error={ServerErrorPage}
    >
      <Layout />
    </ChannelErrors>
  <>
}

`Preact.ChannelErrors#render()`

Returns ComponentChild.

`Preact.ErrorsContext`

Context to pass error handlers from ChannelErrors.

Type: PreactContext.

`Preact.useAuth()`

Hook to return user's current authentication state and ID.

import { useAuth } from '@logux/client/preact'

export const UserPage = () => {
  let { isAuthenticated, userId } = useAuth()
  if (isAuthenticated) {
    return <User id={userId} />
  } else {
    return <Loader />
  }
}

Returns StoreValue.

`Preact.useClient()`

Hook to return Logux client, which you set by <ClientContext.Provider>.

import { useClient } from '@logux/client/preact'

import { User } from '../stores/user'

export const NewUserForm = () => {
  let client = useClient()
  let onAdd = data => {
    User.create(client, data)
  }
}

Returns Client.

`Preact.useFilter(Template, filter?, opts?)`

The way to createFilter in React.

import { useFilter } from '@logux/client/preact'

import { User } from '../stores/user'

export const Users = ({ projectId }) => {
  let users = useFilter(User, { projectId })
  return <div>
    {users.list.map(user => <User user={user} />)}
    {users.isLoading && <Loader />}
  </div>
}

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store class.
`filter` ?	`Filter`	Key-value filter for stores.
`opts` ?	`FilterOptions`	Filter options.

Returns StoreValue. Filter store to use with map.

`Preact.useSync(Template, id)`

Create store by ID, subscribe and get store’s value.

import { useSync } from '@logux/client/preact'

import { User } from '../stores/user'

export const UserPage: FC = ({ id }) => {
  let user = useSync(User, id)
  if (user.isLoading) {
    return <Loader />
  } else {
    return <h1>{user.name}</h1>
  }
}

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store template.
`id`	`string`	Store ID.

Argument	Type	Description
`Template`	`SyncMapTemplate \| SyncMapTemplateLike`	Store template.
`id`	`string`	Store ID.
`args`	`Args`	Other store arguments.

Returns SyncMapValue. Store value.

Client

Base class for browser API to be extended in CrossTabClient.

Because this class could have conflicts between different browser tab, you should use it only if you are really sure, that application will not be run in different tab (for instance, if you are developing a kiosk app).

import { Client } from '@logux/client'

const userId = document.querySelector('meta[name=user]').content
const token = document.querySelector('meta[name=token]').content

const client = new Client({
  credentials: token,
  subprotocol: 1,
  server: 'wss://example.com:1337',
  userId: userId
})
client.start()

Parameter	Type	Description
`opts`	`ClientOptions`	Client options.

`Client#clientId`

Unique permanent client ID. Can be used to track this machine.

Type: string.

`Client#connected`

Is leader tab connected to server.

Type: boolean.

`Client#log`

Client events log.

client.log.add(action)

Type: ClientLog.

`Client#node`

Node instance to synchronize logs.

if (client.node.state === 'synchronized')

Type: ClientNode.

`Client#nodeId`

Unique Logux node ID.

console.log('Client ID: ', client.nodeId)

Type: string.

`Client#options`

Client options.

console.log('Connecting to ' + client.options.server)

Type: ClientOptions.

`Client#state`

Leader tab synchronization state. It can differs from client.node.state (because only the leader tab keeps connection).

client.on('state', () => {
  if (client.state === 'disconnected' && client.state === 'sending') {
    showCloseWarning()
  }
})

Type: ClientNode.

`Client#tabId`

Unique tab ID. Can be used to add an action to the specific tab.

Without localStorage (React Native) there are it is an empty string.

client.log.add(action, { tab: client.tabId })

Type: string.

`Client#changeUser(userId, token?)`

Disconnect from the server, update user, and connect again with new credentials.

onAuth(async (userId, token) => {
  showLoader()
  client.changeUser(userId, token)
  await client.node.waitFor('synchronized')
  hideLoader()
})

You need manually chang user ID in all browser tabs.

Argument	Type	Description
`userId`	`string`	The new user ID.
`token` ?	`string`	Credentials for new user.

`Client#clean()`

Clear stored data. Removes action log from IndexedDB if you used it.

Databases, subscribed to the cleaning event, are cleaned before the log, so the log can’t fill them back.

signout.addEventListener('click', async () => {
  await client.clean()
  location.reload()
})

Returns Promise. Promise when all data will be removed.

`Client#destroy()`

Disconnect and stop synchronization.

shutdown.addEventListener('click', () => {
  client.destroy()
})

`Client#on(event, listener)`

Argument	Type
`event`	`"user"`
`listener`	`(userId: string) => void`

Argument	Type	Description
`event`	`"cleaning"`	The event name.
`listener`	`() => void \| Promise`	The listener function.

Argument	Type	Description
`event`	`"state"`	The event name.
`listener`	`() => void`	The listener function.

Argument	Type
`event`	`"add" \| "clean" \| "preadd"`
`listener`	`ClientActionListener`

Returns Unsubscribe.

`Client#start(connect?)`

Connect to server and reconnect on any connection problem.

client.start()

Argument	Type	Description
`connect` ?	`boolean`	Start connection immediately.

`Client#sync(action, meta?)`

Send action to the server (by setting meta.sync and adding to the log) and track server processing.

showLoader()
client.sync(
  { type: 'CHANGE_NAME', name }
).then(() => {
  hideLoader()
}).catch(error => {
  hideLoader()
  showError(error.action.reason)
})

Argument	Type	Description
`action`	`SyncAction`	The action
`meta` ?	`Partial<ClientMeta>`	Optional meta.

Returns Promise<ClientMeta>. Promise for server processing.

`Client#type(type, listener, opts?)`

Add listener for adding action with specific type. Works faster than on('add', cb) with if.

client.type('rename', (action, meta) => {
  name = action.name
})

Argument	Type	Description
`type`	`TypeAction["type"]`	Action’s type.
`listener`	`ClientActionListener`
`opts` ?	`{ event?: "add" \| "clean" \| "preadd", id?: string }`

Argument	Type	Description
`actionCreator`	`Creator`	Action creator function.
`listener`	`ClientActionListener`
`opts` ?	`{ event?: "add" \| "clean" \| "preadd", id?: string }`

Returns Unsubscribe. Unbind listener from event.

`Client#waitFor(state)`

Wait for specific state of the leader tab.

await client.waitFor('synchronized')
hideLoader()

Argument	Type	Description
`state`	`ClientNode`	State name

Returns Promise.

CrossTabClient

Extends Client.

Low-level browser API for Logux.

Instead of Client, this class prevents conflicts between Logux instances in different tabs on single browser.

import { CrossTabClient } from '@logux/client'

const userId = document.querySelector('meta[name=user]').content
const token = document.querySelector('meta[name=token]').content

const client = new CrossTabClient({
  subprotocol: 1,
  server: 'wss://example.com:1337',
  userId,
  token
})
client.start()

Parameter	Type	Description
`opts`	`ClientOptions`	Client options.

`CrossTabClient#clientId`

Unique permanent client ID. Can be used to track this machine.

Type: string.

`CrossTabClient#connected`

Is leader tab connected to server.

Type: boolean.

`CrossTabClient#isLocalStorage`

Cache for localStorage detection. Can be overridden to disable leader tab election in tests.

Type: boolean.

`CrossTabClient#log`

Client events log.

client.log.add(action)

Type: ClientLog.

`CrossTabClient#node`

Node instance to synchronize logs.

if (client.node.state === 'synchronized')

Type: ClientNode.

`CrossTabClient#nodeId`

Unique Logux node ID.

console.log('Client ID: ', client.nodeId)

Type: string.

`CrossTabClient#options`

Client options.

console.log('Connecting to ' + client.options.server)

Type: ClientOptions.

`CrossTabClient#role`

Current tab role. Only leader tab connects to server. followers just listen to events from leader.

client.on('role', () => {
  console.log('Tab role:', client.role)
})

Type: "follower" | "leader".

`CrossTabClient#state`

Leader tab synchronization state. It can differs from client.node.state (because only the leader tab keeps connection).

client.on('state', () => {
  if (client.state === 'disconnected' && client.state === 'sending') {
    showCloseWarning()
  }
})

Type: ClientNode.

`CrossTabClient#tabId`

Unique tab ID. Can be used to add an action to the specific tab.

Without localStorage (React Native) there are it is an empty string.

client.log.add(action, { tab: client.tabId })

Type: string.

`CrossTabClient#changeUser(userId, token?)`

Disconnect from the server, update user, and connect again with new credentials.

onAuth(async (userId, token) => {
  showLoader()
  client.changeUser(userId, token)
  await client.node.waitFor('synchronized')
  hideLoader()
})

You need manually chang user ID in all browser tabs.

Argument	Type	Description
`userId`	`string`	The new user ID.
`token` ?	`string`	Credentials for new user.

`CrossTabClient#clean()`

Clear stored data. Removes action log from IndexedDB if you used it.

Databases, subscribed to the cleaning event, are cleaned before the log, so the log can’t fill them back.

signout.addEventListener('click', async () => {
  await client.clean()
  location.reload()
})

Returns Promise. Promise when all data will be removed.

`CrossTabClient#destroy()`

Disconnect and stop synchronization.

shutdown.addEventListener('click', () => {
  client.destroy()
})

`CrossTabClient#forceConnect()`

Start web socket reconnection.

`CrossTabClient#on(event, listener)`

Argument	Type
`event`	`"add" \| "clean" \| "preadd"`
`listener`	`ClientActionListener`

Argument	Type	Description
`event`	`"role" \| "state"`	The event name.
`listener`	`() => void`	The listener function.

Argument	Type	Description
`event`	`"user"`	The event name.
`listener`	`(userId: string) => void`	The listener function.

Argument	Type
`event`	`"cleaning"`
`listener`	`() => void \| Promise`

Returns Unsubscribe.

`CrossTabClient#start(connect?)`

Connect to server and reconnect on any connection problem.

client.start()

Argument	Type	Description
`connect` ?	`boolean`	Start connection immediately.

`CrossTabClient#sync(action, meta?)`

Send action to the server (by setting meta.sync and adding to the log) and track server processing.

showLoader()
client.sync(
  { type: 'CHANGE_NAME', name }
).then(() => {
  hideLoader()
}).catch(error => {
  hideLoader()
  showError(error.action.reason)
})

Argument	Type	Description
`action`	`SyncAction`	The action
`meta` ?	`Partial<ClientMeta>`	Optional meta.

Returns Promise<ClientMeta>. Promise for server processing.

`CrossTabClient#type(type, listener, opts?)`

Add listener for adding action with specific type. Works faster than on('add', cb) with if.

client.type('rename', (action, meta) => {
  name = action.name
})

Argument	Type	Description
`type`	`TypeAction["type"]`	Action’s type.
`listener`	`ClientActionListener`
`opts` ?	`{ event?: "add" \| "clean" \| "preadd", id?: string }`

Argument	Type	Description
`actionCreator`	`Creator`	Action creator function.
`listener`	`ClientActionListener`
`opts` ?	`{ event?: "add" \| "clean" \| "preadd", id?: string }`

Returns Unsubscribe. Unbind listener from event.

`CrossTabClient#waitFor(state)`

Wait for specific state of the leader tab.

await client.waitFor('synchronized')
hideLoader()

Argument	Type	Description
`state`	`ClientNode`	State name

Returns Promise.

IndexedStore

Extends unknown.

IndexedDB store for Logux log.

import { IndexedStore } from '@logux/client'
const client = new CrossTabClient({
  …,
  store: new IndexedStore()
})

Parameter	Type	Description
`name` ?	`string`	Database name to run multiple Logux instances on same web page.

`IndexedStore#name`

Database name.

Type: string.

`attention(client)`

Highlight tabs on synchronization errors.

import { attention } from '@logux/client'
attention(client)

Argument	Type	Description
`client`	`Client`	Observed Client instance.

Returns () => void. Unbind listener.

`badge(client, opts)`

Display Logux widget in browser.

import { badge, badgeEn } from '@logux/client'
import { badgeStyles } from '@logux/client/badge/styles'

badge(client, {
 messages: badgeEn,
 styles: {
   ...badgeStyles,
   synchronized: { backgroundColor: 'green' }
 },
 position: 'top-left'
})

Argument	Type	Description
`client`	`Client`	Observed Client instance.
`opts`	`BadgeOptions`	Widget settings.

Returns () => void. Unbind badge listener and remove widget from DOM.

`buildNewSyncMap(client, Template, value)`

Send create action and build store instance.

import { buildNewSyncMap } from '@logux/client'

let userStore = buildNewSyncMap(client, User, {
  id: nanoid(),
  login: 'test'
})

Argument	Type	Description
`client`	`Client`	Logux Client instance.
`Template`	`SyncMapTemplate`	Store template from `syncMapTemplate`.
`value`	`{ id: string } & Value`	Initial value.

Returns Promise<any>. Promise with store instance.

`changeSyncMap(store, diff)`

Change keys in the store’s value.

import { changeSyncMap } from '@logux/client'

showLoader()
await changeSyncMap(userStore, { name: 'New name' })
hideLoader()

Argument	Type	Description
`store`	`any`	Store’s instance.
`diff`	`Partial<Omit<Value,"id">>`	Store’s changes.

Argument	Type	Description
`store`	`any`	Store’s instance.
`key`	`ValueKey`
`value`	`Value[ValueKey]`

Returns Promise. Promise until server validation for remote classes or saving action to the log of fully offline classes.

`changeSyncMapById(client, Template, id, diff)`

Change store without store instance just by store ID.

import { changeSyncMapById } from '@logux/client'

let userStore = changeSyncMapById(client, User, 'user:4hs2jd83mf', {
  name: 'New name'
})

Argument	Type	Description
`client`	`Client`	Logux Client instance.
`Template`	`SyncMapTemplate`	Store template from `syncMapTemplate`.
`id`	`string`	Store’s ID.
`diff`	`Partial<Value>`	Store’s changes.

Argument	Type	Description
`client`	`Client`	Logux Client instance.
`Template`	`SyncMapTemplate`	Store template from `syncMapTemplate`.
`id`	`string`	Store’s ID.
`key`	`ValueKey`
`value`	`Value[ValueKey]`

Returns Promise. Promise until server validation for remote classes or saving action to the log of fully offline classes.

`confirm(client)`

Show confirm popup, when user close tab with non-synchronized actions.

import { confirm } from '@logux/client'
confirm(client)

Argument	Type	Description
`client`	`Client`	Observed Client instance.

Returns () => void. Unbind listener.

`createFilter(client, Template, filter?, opts?)`

Load list of SyncMap with simple key-value requirements.

It will look for stores in loaded cache, log (for offline maps) and will subscribe to list from server (for remote maps).

import { createFilter } from '@logux/client'

import { User } from '../store'

let usersInProject = createFilter(client, User, { projectId })
await usersInProject.loading
console.log(usersInProject.get())

Argument	Type	Description
`client`	`Client`	Logux Client.
`Template`	`SyncMapTemplate`	Store template from `syncMapTemplate`.
`filter` ?	`Filter`	Key-value to filter stores.
`opts` ?	`FilterOptions`	Loading options.

Returns any.

`createSyncMap(client, Template, value)`

Send create action to the server or to the log.

Server will create a row in database on this action. FilterStore will update the list.

import { createSyncMap } from '@logux/client'

showLoader()
await createSyncMap(client, User, {
  id: nanoid(),
  login: 'test'
})
hideLoader()

Argument	Type	Description
`client`	`Client`	Logux Client instance.
`Template`	`SyncMapTemplate`	Store template from `syncMapTemplate`.
`value`	`{ id: string } & Value`	Initial value.

Returns Promise. Promise until server validation for remote classes or saving action to the log of fully offline classes.

`deleteSyncMap(store)`

Delete store.

import { deleteSyncMap } from '@logux/client'

showLoader()
await deleteSyncMap(User)

Argument	Type	Description
`store`	`any`	Store’s instance.

Returns Promise. Promise until server validation for remote classes or saving action to the log of fully offline classes.

`deleteSyncMapById(client, Template, id)`

Delete store without store instance just by store ID.

import { deleteSyncMapById } from '@logux/client'

showLoader()
await deleteSyncMapById(client, User, 'user:4hs2jd83mf')

Argument	Type	Description
`client`	`Client`	Logux Client instance.
`Template`	`SyncMapTemplate`	Store template from `syncMapTemplate`.
`id`	`string`	Store’s ID.

Returns Promise. Promise until server validation for remote classes or saving action to the log of fully offline classes.

`encryptActions(client, secret, opts?)`

Encrypt actions before sending them to server.

Actions will be converted to { type: '0', d: encrypt(action) }

Client will be switched to binary protocol, which has a compact format for encrypted actions. Call it before client.start().

import { encryptActions } from '@logux/client'
encryptActions(client, localStorage.getItem('userPassword'), {
  ignore: ['server/public'] // action.type to not be encrypted
})

Argument	Type	Description
`client`	`Client`	Observed Client instance.
`secret`	`string \| CryptoKey`	Password for encryption, or a CryptoKey AES key.
`opts` ?	`{ clean?: boolean, ignore?: string[] }`	Encryption options.

`favicon(client, links)`

Change favicon to show Logux synchronization status.

import { favicon } from '@logux/client'
favicon(client, {
  normal: '/favicon.ico',
  offline: '/offline.ico',
  error: '/error.ico'
})

Argument	Type	Description
`client`	`Client`	Observed Client instance.
`links`	`FaviconLinks`	Favicon links.

Returns () => void. Unbind listener.

`log(client, messages?)`

Display Logux events in browser console.

import { log } from '@logux/client'
log(client, { ignoreActions: ['user/add'] })

Argument	Type	Description
`client`	`Client`	Observed Client instance.
`messages` ?	`LogMessages`	Disable specific message types.

Returns () => void. Unbind listener.

`request(action, opts)`

Create temporary client instance, send an action, wait response action from the server and destroy client.

Useful for simple actions like signin or signup.

import { request } from '@logux/client'

let action = { type: 'signin', login, password }

request(action, {
  server: 'wss://example.com',
  subprotocol: 10
}).then(response => {
  saveToken(response.token)
}).catch(error => {
  showError(error.action.reason)
})

Argument	Type	Description
`action`	`AnyAction`	Action which we need to send to the server.
`opts`	`RequestOptions`

Returns Promise<SentAction>. Action of server response.

`syncMapTemplate(plural, opts?)`

CRDT LWW Map. It can use server validation or be fully offline.

The best option for classic case with server and many clients. Store will resolve client’s edit conflicts with last write wins strategy.

import { syncMapTemplate } from '@logux/client'

export const User = syncMapTemplate<{
  login: string,
  name?: string,
  isAdmin: boolean
}>('users')

Argument	Type	Description
`plural`	`string`	Plural store name. It will be used in action type and channel name.
`opts` ?	`{ offline?: boolean, remote?: boolean }`	Options to disable server validation or keep actions in log for offline support.

Returns SyncMapTemplate.

TestClient

Extends Client.

Virtual client to test client-side code end store extnesions.

import { TestClient } from '@logux/client'

it('connects and sends actions', async () => {
  let client = new TestClient()
  let user = new UserStore(client, '10')

  client.server.onChannel('users/10', [
    { type: 'users/name', userId: 10, value: 'New name' }
  ])
  await client.connect()
  await delay(10)

  expect(user.name).toEqual('New name')
})

Parameter	Type	Description
`userId`	`string`	User ID.
`opts` ?	`TestClientOptions`	Other options.

`TestClient#clientId`

Unique permanent client ID. Can be used to track this machine.

Type: string.

`TestClient#connected`

Is leader tab connected to server.

Type: boolean.

`TestClient#log`

Client events log.

client.log.add(action)

Type: TestLog.

`TestClient#node`

Node instance to synchronize logs.

if (client.node.state === 'synchronized')

Type: ClientNode.

`TestClient#nodeId`

Unique Logux node ID.

console.log('Client ID: ', client.nodeId)

Type: string.

`TestClient#options`

Client options.

console.log('Connecting to ' + client.options.server)

Type: ClientOptions.

`TestClient#pair`

Connection between client and server.

Type: TestPair.

`TestClient#server`

Virtual server to test client.

expect(client.server.log.actions()).toEqual([
  { type: 'logux/subscribe', channel: 'users/10' }
])

Type: TestServer.

`TestClient#state`

Leader tab synchronization state. It can differs from client.node.state (because only the leader tab keeps connection).

client.on('state', () => {
  if (client.state === 'disconnected' && client.state === 'sending') {
    showCloseWarning()
  }
})

Type: ClientNode.

`TestClient#tabId`

Unique tab ID. Can be used to add an action to the specific tab.

Without localStorage (React Native) there are it is an empty string.

client.log.add(action, { tab: client.tabId })

Type: string.

`TestClient#changeUser(userId, token?)`

Disconnect from the server, update user, and connect again with new credentials.

onAuth(async (userId, token) => {
  showLoader()
  client.changeUser(userId, token)
  await client.node.waitFor('synchronized')
  hideLoader()
})

You need manually chang user ID in all browser tabs.

Argument	Type	Description
`userId`	`string`	The new user ID.
`token` ?	`string`	Credentials for new user.

`TestClient#clean()`

Clear stored data. Removes action log from IndexedDB if you used it.

Databases, subscribed to the cleaning event, are cleaned before the log, so the log can’t fill them back.

signout.addEventListener('click', async () => {
  await client.clean()
  location.reload()
})

Returns Promise. Promise when all data will be removed.

`TestClient#connect()`

Connect to virtual server.

await client.connect()

Returns Promise. Promise until connection will be established.

`TestClient#destroy()`

Disconnect and stop synchronization.

shutdown.addEventListener('click', () => {
  client.destroy()
})

`TestClient#disconnect()`

Disconnect from virtual server.

client.disconnect()

`TestClient#on(event, listener)`

Argument	Type
`event`	`"user"`
`listener`	`(userId: string) => void`

Argument	Type	Description
`event`	`"cleaning"`	The event name.
`listener`	`() => void \| Promise`	The listener function.

Argument	Type	Description
`event`	`"state"`	The event name.
`listener`	`() => void`	The listener function.

Argument	Type
`event`	`"add" \| "clean" \| "preadd"`
`listener`	`ClientActionListener`

Returns Unsubscribe.

`TestClient#sent(test)`

Collect actions sent by client during the test call.

let answers = await client.sent(async () => {
  client.log.add({ type: 'local' })
})
expect(actions).toEqual([{ type: 'local' }])

Argument	Type	Description
`test`	`() => void \| Promise`	Function, where do you expect action will be received

Returns Promise<Action[]>. Promise with all received actions

`TestClient#start(connect?)`

Connect to server and reconnect on any connection problem.

client.start()

Argument	Type	Description
`connect` ?	`boolean`	Start connection immediately.

`TestClient#subscribed(channel)`

Does client subscribed to specific channel.

let user = new UserStore(client, '10')
await delay(10)
expect(client.subscribed('users/10')).toBe(true)

Argument	Type	Description
`channel`	`string`	Channel name.

Returns boolean. Does client has an active subscription.

`TestClient#sync(action, meta?)`

Send action to the server (by setting meta.sync and adding to the log) and track server processing.

showLoader()
client.sync(
  { type: 'CHANGE_NAME', name }
).then(() => {
  hideLoader()
}).catch(error => {
  hideLoader()
  showError(error.action.reason)
})

Argument	Type	Description
`action`	`SyncAction`	The action
`meta` ?	`Partial<ClientMeta>`	Optional meta.

Returns Promise<ClientMeta>. Promise for server processing.

`TestClient#type(type, listener, opts?)`

Add listener for adding action with specific type. Works faster than on('add', cb) with if.

client.type('rename', (action, meta) => {
  name = action.name
})

Argument	Type	Description
`type`	`TypeAction["type"]`	Action’s type.
`listener`	`ClientActionListener`
`opts` ?	`{ event?: "add" \| "clean" \| "preadd", id?: string }`

Argument	Type	Description
`actionCreator`	`Creator`	Action creator function.
`listener`	`ClientActionListener`
`opts` ?	`{ event?: "add" \| "clean" \| "preadd", id?: string }`

Returns Unsubscribe. Unbind listener from event.

`TestClient#waitFor(state)`

Wait for specific state of the leader tab.

await client.waitFor('synchronized')
hideLoader()

Argument	Type	Description
`state`	`ClientNode`	State name

Returns Promise.

TestLog

Extends Log.

Log to be used in tests. It already has memory store, node ID, and special test timer.

Use TestTime to create test log.

import { TestTime } from '@logux/core'

it('tests log', () => {
  const log = TestTime.getLog()
})

it('tests 2 logs', () => {
  const time = new TestTime()
  const log1 = time.nextLog()
  const log2 = time.nextLog()
})

`TestLog#nodeId`

Unique node ID. It is used in action IDs.

Type: string.

`TestLog#store`

Log store.

Type: LogStore.

`TestLog#actions()`

Return all action (without metadata) inside log, sorted by created time.

This shortcut works only with MemoryStore.

expect(log.action).toEqual([
  { type: 'A' }
])

Returns Action[].

`TestLog#add(action, meta?)`

Add action to log.

It will set id, time (if they was missed) and added property to meta and call all listeners.

removeButton.addEventListener('click', () => {
  log.add({ type: 'users:remove', user: id })
})

Argument	Type	Description
`action`	`NewAction`	The new action.
`meta` ?	`Partial<LogMeta>`	Open structure for action metadata.

Argument	Type
`entries`	`[AnyAction, ?][]`

Returns Promise<false | LogMeta>. Promise with meta if action was added to log or false if action was already in log.

`TestLog#addReason(reasons, criteria?)`

Add reason tags to metadata of actions, which are already in the log. Reasons, which action already has, will not be duplicated.

// The action still owns these cells, so it should keep their reasons
log.addReason('last-value', { id: meta.id })

Argument	Type	Description
`reasons`	`string \| string[]`	The reason name or names.
`criteria` ?	`Criteria`	Criteria to select actions for reason adding.

Returns Promise. Promise when adding will be finished.

`TestLog#byId(id)`

Does log already has action with this ID.

if (action.type === 'logux/undo') {
  const [undidAction, undidMeta] = await log.byId(action.id)
  log.changeMeta(meta.id, { reasons: undidMeta.reasons })
}

Argument	Type	Description
`id`	`string`	Action ID.

Returns Promise<[null, null] | [Action, LogMeta]>. Promise with array of action and metadata.

`TestLog#changeMeta(id, diff)`

Change action metadata. You will remove action by setting reasons: [].

await process(action)
log.changeMeta(action, { status: 'processed' })

Argument	Type	Description
`id`	`string`	Action ID.
`diff`	`Partial<LogMeta>`	Object with values to change in action metadata.

Returns Promise<boolean>. Promise with true if metadata was changed or false on unknown ID.

`TestLog#each(opts, callback)`

Argument	Type	Description
`opts`	`GetOptions`	Iterator options.
`callback`	`ActionIterator`	Function will be executed on every action.

Argument	Type	Description
`callback`	`ActionIterator`	Function will be executed on every action.

Argument	Type	Description
`callback`	`ActionIterator`	Function will be executed on every action.

Returns Promise.

`TestLog#entries()`

Return all entries (with metadata) inside log, sorted by created time.

This shortcut works only with MemoryStore.

expect(log.action).toEqual([
  [{ type: 'A' }, { id: '1 test1 0', time: 1, added: 1, reasons: ['t'] }]
])

Returns [Action, ClientMeta][].

`TestLog#generateId()`

Generate next unique action ID.

const id = log.generateId()

Returns string. Unique ID for action.

`TestLog#keepActions()`

Keep actions without meta.reasons in the log by setting test reason during adding to the log.

log.keepActions()
log.add({ type: 'test' })
log.actions() //=> [{ type: 'test' }]

`TestLog#now()`

Current time of this node. Log uses it for meta.time and action ID.

Redefine it to use a custom clock, for instance, in tests.

log.now = () => fakeTime

Returns number. Milliseconds since UNIX epoch.

`TestLog#on(event, listener)`

Subscribe for log events. It implements nanoevents API. Supported events:

preadd: when somebody try to add action to log. It fires before ID check. The best place to add reason.
add: when new action was added to log.
clean: when action was cleaned from store.
batch: when actions from a single Log#add() call were added.

Note, that Log#type() will work faster than on event with if.

log.on('preadd', (action, meta) => {
  if (action.type === 'beep') {
    meta.reasons.push('test')
  }
})

Argument	Type	Description
`event`	`"add" \| "clean"`	The event name.
`listener`	`ReadonlyListener`	The listener function.

Argument	Type	Description
`event`	`"preadd"`	The event name.
`listener`	`PreaddListener`	The listener function.

Argument	Type	Description
`event`	`"batch"`	The event name.
`listener`	`(entries: [Action, LogMeta][]) => void`	The listener function.

Returns Unsubscribe. Unbind listener from event.

`TestLog#removeReason(reasons, criteria?)`

Remove reason tags from actions’ metadata and remove actions without reasons from log.

onSync(lastSent) {
  log.removeReason('unsynchronized', { maxAdded: lastSent })
}

Argument	Type	Description
`reasons`	`string \| string[]`	The reason name or names.
`criteria` ?	`Criteria`	Criteria to select actions for reason removing.

Returns Promise. Promise when cleaning will be finished.

`TestLog#type(type, listener, opts?)`

Add listener for adding action with specific type. Works faster than on('add', cb) with if.

Setting opts.id will filter events ponly from actions with specific action.id.

const unbind = log.type('beep', (action, meta) => {
  beep()
})
function disableBeeps () {
  unbind()
}

Argument	Type	Description
`type`	`NewAction["type"]`	Action’s type.
`listener`	`ReadonlyListener`	The listener function.
`opts` ?	`{ event?: "add" \| "clean", id?: string }`

Argument	Type	Description
`type`	`NewAction["type"]`	Action’s type.
`listener`	`PreaddListener`	The listener function.
`opts`	`{ event: "preadd", id?: string }`

Returns Unsubscribe. Unbind listener from event.

TestPair

Extends LocalPair.

Two paired loopback connections with events tracking to be used in Logux tests.

import { TestPair } from '@logux/core'
it('tracks events', async () => {
  const pair = new TestPair()
  const client = new ClientNode(pair.right)
  await pair.left.connect()
  expect(pair.leftEvents).toEqual('connect')
  await pair.left.send(msg)
  expect(pair.leftSent).toEqual([msg])
})

Parameter	Type	Description
`delay` ?	`number`	Delay for connection and send events. Default is `1`.

`TestPair#delay`

Delay for connection and send events to emulate real connection latency.

Type: number.

`TestPair#left`

First connection. Will be connected to right one after connect().

new ClientNode('client, log1, pair.left)

Type: LocalConnection.

`TestPair#leftEvents`

Emitted events from left connection.

await pair.left.connect()
pair.leftEvents //=> [['connect']]

Type: string[][].

`TestPair#leftNode`

Node instance used in this test, connected with left.

function createTest () {
  test = new TestPair()
  test.leftNode = ClientNode('client', log, test.left)
  return test
}

Type: BaseNode.

`TestPair#leftSent`

Sent messages from left connection.

await pair.left.send(msg)
pair.leftSent //=> [msg]

Type: Message[].

`TestPair#right`

Second connection. Will be connected to right one after connect().

new ServerNode('server, log2, pair.right)

Type: LocalConnection.

`TestPair#rightEvents`

Emitted events from right connection.

await pair.right.connect()
pair.rightEvents //=> [['connect']]

Type: string[][].

`TestPair#rightNode`

Node instance used in this test, connected with right.

function createTest () {
  test = new TestPair()
  test.rightNode = ServerNode('client', log, test.right)
  return test
}

Type: BaseNode.

`TestPair#rightSent`

Sent messages from right connection.

await pair.right.send(msg)
pair.rightSent //=> [msg]

Type: Message[].

`TestPair#clear()`

Clear all connections events and messages to test only last events.

await client.connection.connect()
pair.clear() // Remove all connecting messages
await client.log.add({ type: 'a' })
expect(pair.leftSent).toEqual([
  ['sync', …]
])

`TestPair#wait(receiver?)`

Return Promise until next event.

pair.left.send(['test'])
await pair.wait('left')
pair.leftSend //=> [['test']]

Argument	Type	Description
`receiver` ?	`"left" \| "right"`	Wait for specific receiver event.

Returns Promise<TestPair>. Promise until next event.

TestServer

Virtual server to test client.

let client = new TestClient()
client.server //=> TestServer

`TestServer#log`

All actions received from the client.

expect(client.server.log.actions()).toEqual([
  { type: 'logux/subscribe', channel: 'users/10' }
])

Type: TestLog.

`TestServer#freezeProcessing(test)`

Stop to response with logux/processed on all new action and send logux/processed for all received actions when test callback will be finished.

await client.server.freezeProcessing(() => {
  user.rename('Another name')
  expect(user.nameIsSaving).toBe(true)
})
await delay(10)
expect(user.nameIsSaving).toBe(false)

Argument	Type	Description
`test`	`() => Promise`	Function, where server will not send `logux/processed`.

Returns Promise. Promise until test will be finished.

`TestServer#onChannel(channel, response)`

Define server’s responses for specific channel.

Second call with the same channel name will override previous data.

  client.server.onChannel('users/10', [
    { type: 'users/name', userId: 10, value: 'New name' }
  ])
  let user = new UserStore(client, '10')
  await delay(10)
  expect(user.name).toEqual('New name')

Argument	Type	Description
`channel`	`string`	The channel name.
`response`	`any`	Actions to send back on subscription.

`TestServer#resend(type, resend)`

Set channels for client’s actions.

Argument	Type	Description
`type`	`ResentAction["type"]`	Action type.
`resend`	`(action: ResentAction, meta: ClientMeta) => string \| string[]`	Callback returns channel name.

`TestServer#sendAll(action, meta?)`

Send action to all connected clients.

client.server.sendAll(action)

Argument	Type	Description
`action`	`SentAction`	Action.
`meta` ?	`any`	Action‘s meta.

Returns Promise.

`TestServer#undoAction(action, reason?, extra?)`

Response with logux/undo instead of logux/process on receiving specific action.

client.server.undoAction(
  { type: 'rename', userId: '10', value: 'Bad name' }
)
user.rename('Good name')
user.rename('Bad name')
await delay(10)
expect(user.name).toEqual('Good name')

Argument	Type	Description
`action`	`RevertedAction`	Action to be undone on receiving
`reason` ?	`string`	Optional code for reason. Default is `'error'`.
`extra` ?	`object`	Extra fields to `logux/undo` action.

`TestServer#undoNext(reason?, extra?)`

Response with logux/undo instead of logux/process on next action from the client.

client.server.undoNext()
user.rename('Another name')
await delay(10)
expect(user.name).toEqual('Old name')

Argument	Type	Description
`reason` ?	`string`	Optional code for reason. Default is `'error'`.
`extra` ?	`object`	Extra fields to `logux/undo` action.

TestTime

Creates special logs for test purposes.

Real logs use real time in actions ID, so log content will be different on every test execution.

To fix it Logux has special logs for tests with simple sequence timer. All logs from one test should share same time. This is why you should use log creator to share time between all logs in one test.

import { TestTime } from '@logux/core'

it('tests log', () => {
  const log = TestTime.getLog()
})

it('tests 2 logs', () => {
  const time = new TestTime()
  const log1 = time.nextLog()
  const log2 = time.nextLog()
})

`TestTime.getLog(opts?)`

Shortcut to create time and generate single log. Use it only if you need one log in test.

it('tests log', () => {
  const log = TestTime.getLog()
})

Argument	Type	Description
`opts` ?	`TestLogOptions`	Log options.

Returns TestLog.

`TestTime#lastId`

Last letd number in log’s nodeId.

Type: number.

`TestTime#nextLog(opts?)`

Return next test log in same time.

it('tests 2 logs', () => {
  const time = new TestTime()
  const log1 = time.nextLog()
  const log2 = time.nextLog()
})

Argument	Type	Description
`opts` ?	`TestLogOptions`	Log options.

Returns TestLog.

`emptyInTest(Template)`

Disable loader for filter for this builder.

import { emptyInTest, cleanStores } from '@logux/client'

beforeEach(() => {
  prepareForTest(client, User, { name: 'Test user 1' })
  prepareForTest(client, User, { name: 'Test user 2' })
})

afterEach(() => {
  cleanStores(User)
})

Argument	Type	Description
`Template`	`SyncMapTemplate`	Store builder.

`prepareForTest`

Create and load stores to builder’s cache to use them in tests or storybook.

import { prepareForTest, cleanStores, TestClient } from '@logux/client'

import { User } from '../store'

let client = new TestClient('10')

beforeEach(() => {
  prepareForTest(client, User, { name: 'Test user 1' })
  prepareForTest(client, User, { name: 'Test user 2' })
})

afterEach(() => {
  cleanStores(User)
})

Type: PrepareForTest.

BaseNode

Base methods for synchronization nodes. Client and server nodes are based on this module.

Parameter	Type	Description
`nodeId`	`string`	Unique current machine name.
`log`	`NodeLog`	Logux log instance to be synchronized.
`connection`	`Connection`	Connection to remote node.
`options` ?	`NodeOptions`	Synchronization options.

`BaseNode#authenticated`

Did we finish remote node authentication.

Type: boolean.

`BaseNode#connected`

Is synchronization in process.

node.on('disconnect', () => {
  node.connected //=> false
})

Type: boolean.

`BaseNode#connection`

Connection used to communicate to remote node.

Type: Connection.

`BaseNode#initializing`

Promise for node data initial loadiging.

Type: Promise.

`BaseNode#lastReceived`

Latest remote node’s log added time, which was successfully synchronized. It will be saves in log store.

Type: number.

`BaseNode#lastSent`

Latest current log added time, which was successfully synchronized. It will be saves in log store.

Type: number.

`BaseNode#localNodeId`

Unique current machine name.

console.log(node.localNodeId + ' is started')

Type: string.

`BaseNode#localProtocol`

Used Logux protocol.

if (tool.node.localProtocol !== 1) {
  throw new Error('Unsupported Logux protocol')
}

Type: number.

`BaseNode#log`

Log for synchronization.

Type: NodeLog.

`BaseNode#minProtocol`

Minimum version of Logux protocol, which is supported.

console.log(`You need Logux protocol ${node.minProtocol} or higher`)

Type: number.

`BaseNode#options`

Synchronization options.

Type: NodeOptions.

`BaseNode#remoteHeaders`

Headers set by remote node. By default, it is an empty object.

let message = I18N_ERRORS[node.remoteHeaders.language || 'en']
node.log.add({ type: 'error', message })

Type: Headers | EmptyHeaders.

`BaseNode#remoteNodeId`

Unique name of remote machine. It is undefined until nodes handshake.

console.log('Connected to ' + node.remoteNodeId)

Type: string | undefined.

`BaseNode#remoteProtocol`

Remote node Logux protocol. It is undefined until nodes handshake.

if (node.remoteProtocol >= 5) {
  useNewAPI()
} else {
  useOldAPI()
}

Type: number | undefined.

`BaseNode#remoteSubprotocol`

Remote node’s application subprotocol version.

It is undefined until nodes handshake. If remote node will not send on handshake its subprotocol, it will be set to 0.

if (node.remoteSubprotocol > 9) {
  useNewAPI()
} else {
  useOldAPI()
}

Type: number | undefined.

`BaseNode#state`

Current synchronization state.

disconnected: no connection.
connecting: connection was started and we wait for node answer.
sending: new actions was sent, waiting for answer.
synchronized: all actions was synchronized and we keep connection.

node.on('state', () => {
  if (node.state === 'sending') {
    console.log('Do not close browser')
  }
})

Type: NodeState.

`BaseNode#timeFix`

Time difference between nodes.

Type: number.

`BaseNode#catch(listener)`

Disable throwing a error on error message and create error listener.

node.catch(error => {
  console.error(error)
})

Argument	Type	Description
`listener`	`(error: LoguxError) => void`	The error listener.

Returns Unsubscribe. Unbind listener from event.

`BaseNode#destroy()`

Shut down the connection and unsubscribe from log events.

connection.on('disconnect', () => {
  server.destroy()
})

`BaseNode#on(event, listener)`

Argument	Type
`event`	`"headers"`
`listener`	`(headers: Headers) => void`

Argument	Type
`event`	`"synced"`
`listener`	`(synced: number) => void`

Argument	Type
`event`	`"clientError" \| "error"`
`listener`	`(error: LoguxError) => void`

Argument	Type	Description
`event`	`"connect" \| "debug" \| "headers" \| "state"`	Event name.
`listener`	`() => void`	The listener function.

Argument	Type
`event`	`"debug"`
`listener`	`(type: "error", data: string) => void`

Returns Unsubscribe.

`BaseNode#setLocalHeaders(headers)`

Set headers for current node.

if (navigator) {
  node.setLocalHeaders({ language: navigator.language })
}
node.connection.connect()

Argument	Type	Description
`headers`	`Headers`	The data object will be set as headers for current node.

`BaseNode#waitFor(state)`

Return Promise until sync will have specific state.

If current state is correct, method will return resolved Promise.

await node.waitFor('synchronized')
console.log('Everything is synchronized')

Argument	Type	Description
`state`	`NodeState`	The expected synchronization state value.

Returns Promise. Promise until specific state.

Connection

Abstract interface for connection to synchronize logs over it. For example, WebSocket or Loopback.

`Connection#connected`

Is connection is enabled.

Type: boolean.

`Connection#destroy`

Disconnect and unbind all even listeners.

Type: () => void.

`Connection#connect()`

Start connection. Connection should be in disconnected state from the beginning and start connection only on this method call.

This method could be called again if connection moved to disconnected state.

Returns Promise. Promise until connection will be established.

`Connection#disconnect(reason?)`

Finish current connection.

Argument	Type	Description
`reason` ?	`"destroy" \| "error" \| "timeout"`	Disconnection reason.

`Connection#on(event, listener)`

Argument	Type
`event`	`"disconnect"`
`listener`	`(reason: string) => void`

Argument	Type
`event`	`"error"`
`listener`	`(error: Error) => void`

Argument	Type	Description
`event`	`"connect" \| "connecting" \| "disconnect"`	Event name.
`listener`	`() => void`	Event listener.

Argument	Type
`event`	`"message"`
`listener`	`(msg: Message) => void`

Returns Unsubscribe.

`Connection#send(message)`

Send message to connection.

Argument	Type	Description
`message`	`Message`	The message to be sent.

Log

Stores actions with time marks. Log is main idea in Logux. In most end-user tools you will work with log and should know log API.

import Log from '@logux/core'
const log = new Log({
  store: new MemoryStore(),
  nodeId: 'client:134'
})

log.on('add', beeper)
log.add({ type: 'beep' })

Parameter	Type	Description
`opts`	`LogOptions`	Log options.

`Log#nodeId`

Unique node ID. It is used in action IDs.

Type: string.

`Log#store`

Log store.

Type: Store.

`Log#add(action, meta?)`

Add action to log.

It will set id, time (if they was missed) and added property to meta and call all listeners.

removeButton.addEventListener('click', () => {
  log.add({ type: 'users:remove', user: id })
})

Argument	Type	Description
`action`	`NewAction`	The new action.
`meta` ?	`Partial<LogMeta>`	Open structure for action metadata.

Argument	Type
`entries`	`[AnyAction, ?][]`

Returns Promise<false | LogMeta>. Promise with meta if action was added to log or false if action was already in log.

`Log#addReason(reasons, criteria?)`

Add reason tags to metadata of actions, which are already in the log. Reasons, which action already has, will not be duplicated.

// The action still owns these cells, so it should keep their reasons
log.addReason('last-value', { id: meta.id })

Argument	Type	Description
`reasons`	`string \| string[]`	The reason name or names.
`criteria` ?	`Criteria`	Criteria to select actions for reason adding.

Returns Promise. Promise when adding will be finished.

`Log#byId(id)`

Does log already has action with this ID.

if (action.type === 'logux/undo') {
  const [undidAction, undidMeta] = await log.byId(action.id)
  log.changeMeta(meta.id, { reasons: undidMeta.reasons })
}

Argument	Type	Description
`id`	`string`	Action ID.

Returns Promise<[null, null] | [Action, LogMeta]>. Promise with array of action and metadata.

`Log#changeMeta(id, diff)`

Change action metadata. You will remove action by setting reasons: [].

await process(action)
log.changeMeta(action, { status: 'processed' })

Argument	Type	Description
`id`	`string`	Action ID.
`diff`	`Partial<LogMeta>`	Object with values to change in action metadata.

Returns Promise<boolean>. Promise with true if metadata was changed or false on unknown ID.

`Log#each(opts, callback)`

Argument	Type	Description
`opts`	`GetOptions`	Iterator options.
`callback`	`ActionIterator`	Function will be executed on every action.

Argument	Type	Description
`callback`	`ActionIterator`	Function will be executed on every action.

Argument	Type	Description
`callback`	`ActionIterator`	Function will be executed on every action.

Returns Promise.

`Log#generateId()`

Generate next unique action ID.

const id = log.generateId()

Returns string. Unique ID for action.

`Log#now()`

Current time of this node. Log uses it for meta.time and action ID.

Redefine it to use a custom clock, for instance, in tests.

log.now = () => fakeTime

Returns number. Milliseconds since UNIX epoch.

`Log#on(event, listener)`

Subscribe for log events. It implements nanoevents API. Supported events:

preadd: when somebody try to add action to log. It fires before ID check. The best place to add reason.
add: when new action was added to log.
clean: when action was cleaned from store.
batch: when actions from a single Log#add() call were added.

Note, that Log#type() will work faster than on event with if.

log.on('preadd', (action, meta) => {
  if (action.type === 'beep') {
    meta.reasons.push('test')
  }
})

Argument	Type	Description
`event`	`"add" \| "clean"`	The event name.
`listener`	`ReadonlyListener`	The listener function.

Argument	Type	Description
`event`	`"preadd"`	The event name.
`listener`	`PreaddListener`	The listener function.

Argument	Type	Description
`event`	`"batch"`	The event name.
`listener`	`(entries: [Action, LogMeta][]) => void`	The listener function.

Returns Unsubscribe. Unbind listener from event.

`Log#removeReason(reasons, criteria?)`

Remove reason tags from actions’ metadata and remove actions without reasons from log.

onSync(lastSent) {
  log.removeReason('unsynchronized', { maxAdded: lastSent })
}

Argument	Type	Description
`reasons`	`string \| string[]`	The reason name or names.
`criteria` ?	`Criteria`	Criteria to select actions for reason removing.

Returns Promise. Promise when cleaning will be finished.

`Log#type(type, listener, opts?)`

Add listener for adding action with specific type. Works faster than on('add', cb) with if.

Setting opts.id will filter events ponly from actions with specific action.id.

const unbind = log.type('beep', (action, meta) => {
  beep()
})
function disableBeeps () {
  unbind()
}

Argument	Type	Description
`type`	`NewAction["type"]`	Action’s type.
`listener`	`ReadonlyListener`	The listener function.
`opts` ?	`{ event?: "add" \| "clean", id?: string }`

Argument	Type	Description
`type`	`NewAction["type"]`	Action’s type.
`listener`	`PreaddListener`	The listener function.
`opts`	`{ event: "preadd", id?: string }`

Returns Unsubscribe. Unbind listener from event.

MemoryStore

Extends LogStore.

Simple memory-based log store.

It is good for tests, but not for server or client usage, because it store all data in memory and will lose log on exit.

import { MemoryStore } from '@logux/core'

var log = new Log({
  nodeId: 'server',
  store: new MemoryStore()
})

`MemoryStore#entries`

Actions in the store.

Type: [Action, ClientMeta][].

`MemoryStore#add(action, meta)`

Add action to store. Action always will have type property.

Argument	Type	Description
`action`	`AnyAction`	The action to add.
`meta`	`ClientMeta`	Action’s metadata.

Returns Promise<false | ClientMeta>. Promise with meta for new action or false if action with same meta.id was already in store.

`MemoryStore#addReason(reasons, criteria)`

Add reasons to metadata of actions, which are already in the store.

Reasons, which action already has, should not be duplicated.

Argument	Type	Description
`reasons`	`string[]`	The reason names.
`criteria`	`Criteria`	Criteria to select actions for reason adding.

Returns Promise. Promise when adding will be finished.

`MemoryStore#byId(id)`

Return action by action ID.

Argument	Type	Description
`id`	`string`	Action ID.

Returns Promise<[null, null] | [Action, ClientMeta]>. Promise with array of action and metadata.

`MemoryStore#changeMeta(id, diff)`

Change action metadata.

Argument	Type	Description
`id`	`string`	Action ID.
`diff`	`Partial<ClientMeta>`	Object with values to change in action metadata.

Returns Promise<boolean>. Promise with true if metadata was changed or false on unknown ID.

`MemoryStore#clean()`

Remove all data from the store.

Returns Promise. Promise when cleaning will be finished.

`MemoryStore#get(opts?)`

Return a Promise with first page. Page object has entries property with part of actions and next property with function to load next page. If it was a last page, next property should be empty.

This tricky API is used, because log could be very big. So we need pagination to keep them in memory.

Argument	Type	Description
`opts` ?	`GetOptions`	Query options.

Returns Promise<LogPage>. Promise with first page.

`MemoryStore#getLastAdded()`

Return biggest added number in store. All actions in this log have less or same added time.

Returns Promise<number>. Promise with biggest added number.

`MemoryStore#getLastSynced()`

Get added values for latest synchronized received/sent events.

Returns Promise<LastSynced>. Promise with added values

`MemoryStore#remove(id)`

Remove action from store.

Argument	Type	Description
`id`	`string`	Action ID.

Returns Promise<false | [Action, ClientMeta]>. Promise with entry if action was in store.

`MemoryStore#removeReason(reasons, criteria, callback)`

Remove reasons from action’s metadata and remove actions without reasons.

Argument	Type	Description
`reasons`	`string[]`	The reason names.
`criteria`	`Criteria`	Criteria to select actions for reason removing.
`callback`	`ReadonlyListener`	Callback for every removed action.

Returns Promise. Promise when cleaning will be finished.

`MemoryStore#setLastSynced(values)`

Set added value for latest synchronized received or/and sent events.

Argument	Type	Description
`values`	`Partial<LastSynced>`	Object with latest sent or received values.

Returns Promise. Promise when values will be saved to store.

Reconnect

Extends Connection.

Wrapper for Connection for re-connecting it on every disconnect.

import { ClientNode, Reconnect } from '@logux/core'
const recon = new Reconnect(connection)
new ClientNode(nodeId, log, recon, options)

Parameter	Type	Description
`connection`	`Connection`	The connection to be re-connectable.
`options` ?	`ReconnectOptions`	Re-connection options.

`Reconnect#attempts`

Fails attempts since the last connected state.

Type: number.

`Reconnect#connected`

Is connection is enabled.

Type: boolean.

`Reconnect#connecting`

Are we in the middle of connecting.

Type: boolean.

`Reconnect#connection`

Wrapped connection.

Type: Connection.

`Reconnect#destroy`

Unbind all listeners and disconnect. Use it if you will not need this class anymore.

Type: () => void.

`Reconnect#options`

Re-connection options.

Type: ReconnectOptions.

`Reconnect#reconnecting`

Should we re-connect connection on next connection break. Next connect call will set to true.

function lastTry () {
  recon.reconnecting = false
}

Type: boolean.

`Reconnect#connect()`

Start connection. Connection should be in disconnected state from the beginning and start connection only on this method call.

This method could be called again if connection moved to disconnected state.

Returns Promise. Promise until connection will be established.

`Reconnect#disconnect(reason?)`

Finish current connection.

Argument	Type	Description
`reason` ?	`"destroy" \| "error" \| "timeout"`	Disconnection reason.

`Reconnect#on(event, listener)`

Argument	Type
`event`	`"disconnect"`
`listener`	`(reason: string) => void`

Argument	Type
`event`	`"error"`
`listener`	`(error: Error) => void`

Argument	Type	Description
`event`	`"connect" \| "connecting" \| "disconnect"`	Event name.
`listener`	`() => void`	Event listener.

Argument	Type
`event`	`"message"`
`listener`	`(msg: Message) => void`

Returns Unsubscribe.

`Reconnect#send(message)`

Send message to connection.

Argument	Type	Description
`message`	`Message`	The message to be sent.

`defineAction`

Type: DefineAction.

`isFirstOlder(firstMeta, secondMeta)`

Compare time, when log entries were created.

It uses meta.time and meta.id to detect entries order.

import { isFirstOlder } from '@logux/core'
if (isFirstOlder(lastBeep, meta) {
  beep(action)
  lastBeep = meta
}

Argument	Type	Description
`firstMeta`	`string \| ClientMeta \| undefined`	Some action’s metadata.
`secondMeta`	`string \| ClientMeta \| undefined`	Other action’s metadata.

Returns boolean.

`parseId(id)`

Parse meta.id or Node ID into component: user ID, client ID, node ID.

import { parseId } from '@logux/core'
const { userId, clientId } = parseId(meta.id)

Argument	Type	Description
`id`	`string`	Action or Node ID

Returns IDComponents.

`AbstractActionCreator(args)`

Argument	Type
`args`	`any[]`

Returns CreatedAction.

`AbstractActionCreator#type`

Type: string.

`AbstractCrdtTable`

Property	Type
`plural`	`string`
`create`	`(fields: AbstractNewCrdtRow[] \| AbstractNewCrdtRow) => Promise<string \| string[]>`
`update`	`(id: string, diff: Partial<RowFields>) => Promise`

`AbstractNewCrdtRow`

Type: { id?: string } & CreateFields.

`Action`

Property	Type	Description
`type`	`string`	Action type name.

`ActionCreator(args)`

Argument	Type
`args`	`CreatorArgs`

Returns CreatedAction.

`ActionCreator#match`

Type: (action: Action) => action is CreatedAction.

`ActionCreator#type`

Type: string.

`ActionFilter(action, meta)`

Argument	Type
`action`	`Action`
`meta`	`ClientMeta`

Returns false | Promise<false | [Action, ClientMeta]> | [Action, ClientMeta].

`ActionIterator(action, meta)`

Argument	Type
`action`	`Action`
`meta`	`LogMeta`

Returns void | boolean.

`ActionListener(action, meta)`

Argument	Type
`action`	`ListenAction`
`meta`	`any`

Returns void | Promise.

`ActionPacker`

Packer of actions with binary parts to binary format to use it in custom packers in SQL-based log stores.

Property	Type
`pack`	`(action: FullAction) => PackedAction \| undefined`
`unpack`	`(action: PackedAction) => FullAction`

`ActionPackerMap`

Checks that every key of the packers map is equal to type of the action, which packer packs.

function createStore<Packers extends ActionPackerMap<Packers>>(
  packers: Packers
): Store

createStore({ '0': zeroPacker })

Type: { [Type: keyof Packers]: Type ? ActionPacker : never }.

`AnyAction`

Property	Type
`type`	`string`

`Authenticator(nodeId, token, headers)`

Argument	Type
`nodeId`	`string`
`token`	`string`
`headers`	`object \| Headers`

Returns Promise<boolean>.

`AuthStore`

Auth store. Use createAuth to create it.

Property	Type	Description
`loading`	`Promise`	While store is loading initial state.

`BadgeMessages`

Property	Type
`denied`	`string`
`disconnected`	`string`
`error`	`string`
`protocolError`	`string`
`sending`	`string`
`syncError`	`string`
`synchronized`	`string`
`wait`	`string`

`BadgeOptions`

Property	Type	Description
`duration` ?	`number`	Synchronized state duration. Default is `3000`.
`messages`	`BadgeMessages`	Widget text for different states.
`position` ?	`"bottom-center" \| "bottom-left" \| "bottom-right" \| "middle-center" \| "middle-left" \| "middle-right" \| "top-center" \| "top-left" \| "top-right"`	Widget position. Default is `bottom-right`.
`styles`	`BadgeStyles`	Inline styles for different states.

`BadgeStyles`

Property	Type
`base`	`object`
`connecting`	`object`
`disconnected`	`object`
`error`	`object`
`icon`	`{ disconnected: string, error: string, protocolError: string, sending: string, synchronized: string, wait: string }`
`protocolError`	`object`
`sending`	`object`
`synchronized`	`object`
`text`	`object`
`wait`	`object`

`ChannelDeniedError`

Type: LoguxUndoError.

`ChannelError`

Type: ChannelDeniedError | ChannelNotFoundError | ChannelServerError.

`ChannelNotFoundError`

Type: LoguxUndoError.

`ChannelServerError`

Type: LoguxUndoError.

`ClientActionListener(action, meta)`

Argument	Type
`action`	`ListenAction`
`meta`	`ClientMeta`

`ClientMeta`

Property	Type	Description
`noAutoReason` ?	`boolean`	Disable setting `timeTravel` reason.
`sync` ?	`boolean`	This action should be synchronized with other browser tabs and server.
`tab` ?	`string`	Action should be visible only for browser tab with the same `client.tabId`.

ClientNode

Extends BaseNode.

Client node in synchronization pair.

Instead of server node, it initializes synchronization and sends connect message.

import { ClientNode } from '@logux/core'
const connection = new BrowserConnection(url)
const node = new ClientNode(nodeId, log, connection)

Parameter	Type	Description
`nodeId`	`string`	Unique current machine name.
`log`	`NodeLog`	Logux log instance to be synchronized.
`connection`	`Connection`	Connection to remote node.
`options` ?	`NodeOptions`	Synchronization options.

`ClientNode#authenticated`

Did we finish remote node authentication.

Type: boolean.

`ClientNode#connected`

Is synchronization in process.

node.on('disconnect', () => {
  node.connected //=> false
})

Type: boolean.

`ClientNode#connection`

Connection used to communicate to remote node.

Type: Connection.

`ClientNode#initializing`

Promise for node data initial loadiging.

Type: Promise.

`ClientNode#lastReceived`

Latest remote node’s log added time, which was successfully synchronized. It will be saves in log store.

Type: number.

`ClientNode#lastSent`

Latest current log added time, which was successfully synchronized. It will be saves in log store.

Type: number.

`ClientNode#localNodeId`

Unique current machine name.

console.log(node.localNodeId + ' is started')

Type: string.

`ClientNode#localProtocol`

Used Logux protocol.

if (tool.node.localProtocol !== 1) {
  throw new Error('Unsupported Logux protocol')
}

Type: number.

`ClientNode#log`

Log for synchronization.

Type: NodeLog.

`ClientNode#minProtocol`

Minimum version of Logux protocol, which is supported.

console.log(`You need Logux protocol ${node.minProtocol} or higher`)

Type: number.

`ClientNode#options`

Synchronization options.

Type: NodeOptions.

`ClientNode#remoteHeaders`

Headers set by remote node. By default, it is an empty object.

let message = I18N_ERRORS[node.remoteHeaders.language || 'en']
node.log.add({ type: 'error', message })

Type: Headers | EmptyHeaders.

`ClientNode#remoteNodeId`

Unique name of remote machine. It is undefined until nodes handshake.

console.log('Connected to ' + node.remoteNodeId)

Type: string | undefined.

`ClientNode#remoteProtocol`

Remote node Logux protocol. It is undefined until nodes handshake.

if (node.remoteProtocol >= 5) {
  useNewAPI()
} else {
  useOldAPI()
}

Type: number | undefined.

`ClientNode#remoteSubprotocol`

Remote node’s application subprotocol version.

It is undefined until nodes handshake. If remote node will not send on handshake its subprotocol, it will be set to 0.

if (node.remoteSubprotocol > 9) {
  useNewAPI()
} else {
  useOldAPI()
}

Type: number | undefined.

`ClientNode#state`

Current synchronization state.

disconnected: no connection.
connecting: connection was started and we wait for node answer.
sending: new actions was sent, waiting for answer.
synchronized: all actions was synchronized and we keep connection.

node.on('state', () => {
  if (node.state === 'sending') {
    console.log('Do not close browser')
  }
})

Type: NodeState.

`ClientNode#timeFix`

Time difference between nodes.

Type: number.

`ClientNode#catch(listener)`

Disable throwing a error on error message and create error listener.

node.catch(error => {
  console.error(error)
})

Argument	Type	Description
`listener`	`(error: LoguxError) => void`	The error listener.

Returns Unsubscribe. Unbind listener from event.

`ClientNode#destroy()`

Shut down the connection and unsubscribe from log events.

connection.on('disconnect', () => {
  server.destroy()
})

`ClientNode#on(event, listener)`

Argument	Type
`event`	`"headers"`
`listener`	`(headers: Headers) => void`

Argument	Type
`event`	`"synced"`
`listener`	`(synced: number) => void`

Argument	Type
`event`	`"clientError" \| "error"`
`listener`	`(error: LoguxError) => void`

Argument	Type	Description
`event`	`"connect" \| "debug" \| "headers" \| "state"`	Event name.
`listener`	`() => void`	The listener function.

Argument	Type
`event`	`"debug"`
`listener`	`(type: "error", data: string) => void`

Returns Unsubscribe.

`ClientNode#setLocalHeaders(headers)`

Set headers for current node.

if (navigator) {
  node.setLocalHeaders({ language: navigator.language })
}
node.connection.connect()

Argument	Type	Description
`headers`	`Headers`	The data object will be set as headers for current node.

`ClientNode#waitFor(state)`

Return Promise until sync will have specific state.

If current state is correct, method will return resolved Promise.

await node.waitFor('synchronized')
console.log('Everything is synchronized')

Argument	Type	Description
`state`	`NodeState`	The expected synchronization state value.

Returns Promise. Promise until specific state.

`ClientOptions`

Property	Type	Description
`allowDangerousProtocol` ?	`boolean`	Do not show warning when using `ws://` in production.
`attempts` ?	`number`	Maximum reconnection attempts. Default is `Infinity`.
`maxDelay` ?	`number`	Maximum delay between reconnections. Default is `5000`.
`minDelay` ?	`number`	Minimum delay between reconnections. Default is `1000`.
`ping` ?	`number`	Milliseconds since last message to test connection by sending ping. Default is `10000`.
`prefix` ?	`string`	Prefix for `IndexedDB` database to run multiple Logux instances in the same browser. Default is `logux`.
`server`	`any`	Server URL.
`store` ?	`any`	Store to save log data. Default is `MemoryStore`.
`subprotocol`	`number`	Client subprotocol version.
`time` ?	`any`	Test time to test client.
`timeout` ?	`number`	Timeout in milliseconds to break connection. Default is `70000`.
`token` ?	`any`	Client credentials for authentication.
`userId`	`string`	User ID.

`Convertor`

Property	Type
`decode`	`(str: string) => Value`
`encode`	`(value: Value) => string`

`CrdtActionOptions`

Property	Type	Description
`version` ?	`number`	Version of the callback’s logic. Adding or removing an action re-creates the database from the log automatically, but a change inside the callback is not visible to the library. Increase this number to re-create the database after such change.

`CrdtAppliedListener`

Listener of the applied event.

Type: (tx: Database, action: Action, meta: ClientMeta | MetaTime, won: CrdtCell[], touched: CrdtCell[]) => Promise | void.

`CrdtCell`

Single field of a single row: [table, id, field].

Type: [table: string, id: string, field: string].

`CrdtColumn`

Column definition created by string, number, bigint, boolean, oneOf and optional builders.

Type is the JS type of the column value in rows. RequiredOnCreate marks whether CrdtTable#create requires the field (columns wrapped in optional() or having default don’t).

Property	Type	Description
`default` ?	`Type \| () => Type`
`required`	`RequiredOnCreate`
`sql` ?	`string \| { [key: string]: string }`
`type`	`"BIGINT" \| "BOOLEAN" \| "DOUBLE PRECISION" \| "TEXT"`	SQL column type used in `CREATE TABLE`.
`values` ?	`readonly string[]`

`CrdtColumnOptions`

Property	Type	Description
`default` ?	`() => NoInfer \| NoInfer`	Default value or function to get it. Column with default becomes optional in `CrdtTable#create`. The default is resolved when the create action is added and is stored inside the action, so replaying the log is deterministic.
`sql` ?	`string \| { [key: Dialects]: string }`	Extra SQL appended to the column definition, like `'UNIQUE COLLATE NOCASE'`. Pass a string to use it for every database, or an object with `CrdtDatabaseOptions#dialect` names as keys to set SQL per database dialect.

`CrdtColumnType`

Type: Column ? Type : never.

`CrdtColumnValue`

JS types of column values. Only JSON types are supported, because all values are stored in Logux actions and passed to the database driver as-is. Store dates as a number of milliseconds in bigint columns.

Type: SyncMapTypes.

`CrdtCorruption`

Reason why the local database can not be trusted anymore:

error: the database threw the error and can not be prepared.
interrupted-migration: the tab was closed during the schema migration, between the drop of the tables and the end of the replay.
lost-database: the data is gone. The client did not find the database it was using before: the file was lost or replaced by an empty one.
timeout: the database did not answer in CrdtDatabaseOptions#timeout.

Type: "error" | "interrupted-migration" | "lost-database" | "timeout".

`CrdtCreateFields`

Fields accepted by CrdtTable#create. Columns wrapped in optional or having default can be omitted.

Type: { [Column: keyof Schema]?: undefined ? Exclude<CrdtColumnType,undefined> | null : CrdtColumnType } & { [Column: keyof Schema]: CrdtColumnType }.

`CrdtDatabase`

Property	Type	Description
`ready`	`Promise`	Promise resolved when the database was prepared and tables can be used.
`status`	`ReadableAtom`	Database preparing status:
`tables`	`CrdtTables`	Schemas of all tables of `CrdtDatabase#table` by their plural.
`action`	`(creator: Creator, apply: (tx: Database, action: ReturnType<Creator>, meta: ClientMeta) => void \| Promise, opts?: CrdtActionOptions) => (args: Parameters) => Promise`
`clean`	`() => Promise`
`destroy`	`() => void`
`empty`	`() => Promise`
`on`	`(event: "applied", listener: CrdtAppliedListener) => Unsubscribe`
`table`	`(plural: string, schema: Schema, indexes?: CrdtIndex[]) => CrdtTable`

`CrdtDatabaseOptions`

Property	Type	Description
`dialect` ?	`Dialect`	SQL dialect of the database: `'sqlite'` (default), `'pglite'` or any other name for your own dialect. The dialect selects per-dialect extra column SQL in `CrdtColumnOptions#sql` and prohibits `boolean` columns in SQLite (values are passed to the database driver without conversion and SQLite has no boolean type).
`key` ?	`string`	Storage key to store the schema version (also used as the prefix of the leader tab lock name). Change it when the database is used in a third-party widget to avoid conflicts with the website’s own Logux database. Default is `logux:db`.
`storage` ?	`PersistentStorage`	Storage to keep the tables schema instead of `localStorage` (for instance, for React Native or tests).
`sync` ?	`boolean`	Should table actions be sent to the server. Default is `true`.
`timeout` ?	`number`	Milliseconds to wait for the database to be prepared.
`repeat` ?	`() => [Action, MetaTime][] \| Promise<[Action, MetaTime][]>`

`CrdtIndex`

Index definition for CrdtDatabase#table. It can be:

a column name for a single-column index;
an array of columns for a multi-column index;
an object with columns and unique;
an object with the whole CREATE INDEX statement in sql for partial indexes, expressions and dialect-specific features.

let user = crdt.table('user', schema, [
  'email',
  ['teamId', 'name'],
  { columns: ['email'], unique: true },
  {
    sql: `CREATE INDEX IF NOT EXISTS "user_active" ON "user" ("name")` +
      ` WHERE "role" = 'admin'`
  }
])

Type: { columns: CrdtIndexColumn[], unique?: boolean } | { sql: string } | CrdtIndexColumn | CrdtIndexColumn[].

`CrdtIndexColumn`

Column in CrdtIndex: a column name from the table schema, id, or an updatedAt_field column.

Everything after the column name is passed to the database as is, so it can contain DESC, COLLATE or an operator class:

let post = crdt.table('post', schema, [
  'publishedAt DESC',
  'title COLLATE NOCASE'
])

Type: `${CrdtIndexName} ${string}` | CrdtIndexName.

`CrdtParsedAction`

Property	Type	Description
`plural`	`string`	Table name from the action type.
`rows`	`[id: string, fields: string[]][]`	Rows of the action with the names of the fields it writes to them. A `plural/deleted` action writes no fields.
`verb`	`CrdtVerb`	Verb from the action type.

`CrdtParsedType`

Property	Type	Description
`plural`	`string`	Table name from the action type.
`verb`	`CrdtVerb`	Verb from the action type.

`CrdtRowFields`

Row fields (without id and fields meta) inferred from table schema. Optional columns take null to clear the value (undefined fields are not changed, like in JSON).

Type: { [Column: keyof Schema]?: Exclude<CrdtColumnType,undefined> | null } & { [Column: keyof Schema]: CrdtColumnType }.

`CrdtSqlParam`

Values for SQL template parameters of CrdtTable#select. Parameters are passed to the database driver as-is, without any conversion. Booleans are allowed only in dialects with boolean columns (not in 'sqlite').

Type: Dialect ? never : boolean | number | string.

`CrdtTable`

Property	Type	Description
`driver`	`Driver`	Database driver for raw queries to the table, like in `crdtTableToActions`.
`plural`	`string`	Table name. It is used as SQL table name and as prefix of action types (`user/created`, `user/changed`, `user/deleted`).
`schema`	`Schema`	Column definitions of the table.
`change`	`(tx: Database, id: string \| string[], fields: Partial<CrdtRowFields>, meta: ClientMeta) => Promise<CrdtCell[]>`
`create`	`(rows: NewCrdtRow[]) => Promise<string[]>`
`delete`	`(id: string \| string[]) => Promise`
`select`	`(sql?: TemplateStringsArray, params: CrdtSqlParam[]) => SqlStore`
`update`	`(id: string \| string[], diff: Partial<CrdtRowFields>) => Promise`

`CrdtTableChangedAction`

Type: { fields: Partial<Fields>, id: string, type: string } | { fields: Partial<Fields>, ids: string[], type: string }.

`CrdtTableCreatedAction`

Type: { fields: Fields, id: string, type: string } | { records: Fields & { id: string }[], type: string }.

`CrdtTableDeletedAction`

Type: { id: string, type: string } | { ids: string[], type: string }.

`CrdtTableRow`

Table row returned by CrdtTable#select. Rows contain data as the database driver returns it, without any conversion. Missing optional columns are null.

Every field has an extra updatedAt_field column with Logux Meta ID of the last action which changed it (null if the field was never set). They are used to resolve conflicts with per-field last write wins, and can be used in SQL, for instance, to sort by the last change:

let $recent = user.select`ORDER BY "updatedAt_name" DESC`

Type: { id: string } & { [Column: keyof Schema]: undefined ? Exclude<CrdtColumnType,undefined> | null : CrdtColumnType } & { [Column: keyof Schema]: null | string }.

`CrdtTables`

Schemas of the tables by their plural, like CrdtDatabase#tables.

Type: { [key: string]: CrdtTableSchema }.

`CrdtTableSchema`

`CrdtTasks`

Property	Type
`add`	`(task: () => void \| Promise) => void`
`destroy`	`() => void`
`finish`	`() => Promise`

`CrdtTasksOptions`

Property	Type	Description
`onError` ?	`(error: unknown) => void`	Called when the task throws.

`CrdtVerb`

Type: "changed" | "created" | "deleted".

`CreateClientStore(userIdStore, builder)`

Create stores to keep client instance and update it on user ID changes.

import { createClientStore, Client, log } from '@logux/client'
import { persistentMap } from '@nanostores/persistent'

let sessionStore = persistentMap<{ userId: string }>('session:', {
  userId: 'anonymous'
})

export const clientStore = createClientStore(sessionStore, session => {
  let client new Client({
    subprotocol: SUBPROTOCOL,
    server: 'ws://example.com',
    userId: session.userId
  })
  log(client)
  return client
})

Argument	Type	Description
`userIdStore`	`MapStore<UserId>`	Store with object and `userId` key.
`builder`	`(value: UserId) => Client`	Callback which return client

Argument	Type
`userIdStore`	`MapStore<UserId>`
`builder`	`(value: UserId) => Client \| undefined`

Returns Atom<Client>. Atom store with client

`Criteria`

Property	Type	Description
`exceptIndex` ?	`string`	Do not change reasons for actions with this index in `meta.indexes`.
`id` ?	`string`	Change reasons only for action with `id`.
`ids` ?	`string[]`	Change reasons only for actions with these IDs.
`index` ?	`string`	Change reasons only for actions with this index in `meta.indexes`.
`maxAdded` ?	`number`	Change reasons only for actions with lower `added`.
`minAdded` ?	`number`	Change reasons only for actions with bigger `added`.
`olderThan` ?	`ClientMeta`	Change reasons only for actions older than specific action.
`youngerThan` ?	`ClientMeta`	Change reasons only for actions younger than specific action.

`Dialects`

Type: "sqlite" | "pglite".

`EmptyHeaders`

`FaviconLinks`

Property	Type	Description
`error` ?	`string`	Error favicon link.
`normal` ?	`string`	Default favicon link. By default, it will be taken from current favicon.
`offline` ?	`string`	Offline favicon link.

`Fields`

`Filter`

Type: { [Key: keyof Value]?: Value[Key] }.

Property	Type
`listChangesOnly` ?	`boolean`

`FilterStore`

Type: FilterStoreExt & MapStore<FilterValue>.

`FilterStoreExt`

Property	Type	Description
`loading`	`Promise`	While store is loading initial data from server or log.

`FilterValue`

Type: { isLoading: true } | LoadedFilterValue.

`GetOptions`

Property	Type	Description
`index` ?	`string`	Get entries with a custom index.
`order` ?	`"added" \| "created"`	Sort entries by created time or when they was added to current log.
`reason` ?	`string`	Get only entries with this reason.

`ID`

Action unique ID across all nodes.

"OzcVoWD 380:R7BNGA:1"

Type: string.

`IDComponents`

Property	Type
`clientId`	`string`
`nodeId`	`string`
`userId`	`string \| undefined`

`LastSynced`

Property	Type	Description
`received`	`number`	The `added` value of latest received event.
`sent`	`number`	The `added` value of latest sent event.

`LoadableStore`

Type: { loading: Promise<unknown> } & ReadableAtom.

`LoadedFilter`

Type: FilterStoreExt & MapStore<LoadedFilterValue>.

`LoadedFilterValue`

Property	Type
`isEmpty`	`boolean`
`isLoading`	`false`
`list`	`LoadedSyncMapValue[]`
`stores`	`Map<string,SyncMapStore>`

`LoadedSyncMap`

Type: MapStore<LoadedSyncMapValue> & SyncMapStoreExt.

`LoadedSyncMapValue`

Type: { id: string, isLoading: false } & Value.

`LoadedValue`

Type: { isLoading: false } & Type.

LocalConnection

Extends Connection.

Abstract interface for connection to synchronize logs over it. For example, WebSocket or Loopback.

`LocalConnection#connected`

Is connection is enabled.

Type: boolean.

`LocalConnection#destroy`

Disconnect and unbind all even listeners.

Type: () => void.

`LocalConnection#connect()`

Start connection. Connection should be in disconnected state from the beginning and start connection only on this method call.

This method could be called again if connection moved to disconnected state.

Returns Promise. Promise until connection will be established.

`LocalConnection#disconnect(reason?)`

Finish current connection.

Argument	Type	Description
`reason` ?	`"destroy" \| "error" \| "timeout"`	Disconnection reason.

`LocalConnection#on(event, listener)`

Argument	Type
`event`	`"disconnect"`
`listener`	`(reason: string) => void`

Argument	Type
`event`	`"error"`
`listener`	`(error: Error) => void`

Argument	Type	Description
`event`	`"connect" \| "connecting" \| "disconnect"`	Event name.
`listener`	`() => void`	Event listener.

Argument	Type
`event`	`"message"`
`listener`	`(msg: Message) => void`

Returns Unsubscribe.

`LocalConnection#other()`

Returns LocalConnection.

`LocalConnection#send(message)`

Send message to connection.

Argument	Type	Description
`message`	`Message`	The message to be sent.

LocalPair

Two paired loopback connections.

import { LocalPair, ClientNode, ServerNode } from '@logux/core'
const pair = new LocalPair()
const client = new ClientNode('client', log1, pair.left)
const server = new ServerNode('server', log2, pair.right)

Parameter	Type	Description
`delay` ?	`number`	Delay for connection and send events. Default is `1`.

`LocalPair#delay`

Delay for connection and send events to emulate real connection latency.

Type: number.

`LocalPair#left`

First connection. Will be connected to right one after connect().

new ClientNode('client, log1, pair.left)

Type: LocalConnection.

`LocalPair#right`

Second connection. Will be connected to right one after connect().

new ServerNode('server, log2, pair.right)

Type: LocalConnection.

`LogMessages`

Property	Type	Description
`add` ?	`boolean`	Disable action added messages.
`clean` ?	`boolean`	Disable action cleaned messages.
`error` ?	`boolean`	Disable error messages.
`ignoreActions` ?	`string[]`	Disable action messages with specific types.
`role` ?	`boolean`	Disable tab role messages.
`state` ?	`boolean`	Disable connection state messages.
`user` ?	`boolean`	Disable user ID changing.

`LogOptions`

Property	Type	Description
`nodeId`	`string`	Unique current machine name.
`store`	`Store`	Store for log.

`LogPage`

Property	Type	Description
`entries`	`[Action, ClientMeta][]`	Pagination page.
`next` ?	`() => Promise<LogPage>`

LogStore

Every Store class should provide 8 standard methods.

`LogStore#add(action, meta)`

Add action to store. Action always will have type property.

Argument	Type	Description
`action`	`AnyAction`	The action to add.
`meta`	`ClientMeta`	Action’s metadata.

Returns Promise<false | ClientMeta>. Promise with meta for new action or false if action with same meta.id was already in store.

`LogStore#addReason(reasons, criteria)`

Add reasons to metadata of actions, which are already in the store.

Reasons, which action already has, should not be duplicated.

Argument	Type	Description
`reasons`	`string[]`	The reason names.
`criteria`	`Criteria`	Criteria to select actions for reason adding.

Returns Promise. Promise when adding will be finished.

`LogStore#byId(id)`

Return action by action ID.

Argument	Type	Description
`id`	`string`	Action ID.

Returns Promise<[null, null] | [Action, ClientMeta]>. Promise with array of action and metadata.

`LogStore#changeMeta(id, diff)`

Change action metadata.

Argument	Type	Description
`id`	`string`	Action ID.
`diff`	`Partial<ClientMeta>`	Object with values to change in action metadata.

Returns Promise<boolean>. Promise with true if metadata was changed or false on unknown ID.

`LogStore#clean()`

Remove all data from the store.

Returns Promise. Promise when cleaning will be finished.

`LogStore#get(opts?)`

Return a Promise with first page. Page object has entries property with part of actions and next property with function to load next page. If it was a last page, next property should be empty.

This tricky API is used, because log could be very big. So we need pagination to keep them in memory.

Argument	Type	Description
`opts` ?	`GetOptions`	Query options.

Returns Promise<LogPage>. Promise with first page.

`LogStore#getLastAdded()`

Return biggest added number in store. All actions in this log have less or same added time.

Returns Promise<number>. Promise with biggest added number.

`LogStore#getLastSynced()`

Get added values for latest synchronized received/sent events.

Returns Promise<LastSynced>. Promise with added values

`LogStore#remove(id)`

Remove action from store.

Argument	Type	Description
`id`	`string`	Action ID.

Returns Promise<false | [Action, ClientMeta]>. Promise with entry if action was in store.

`LogStore#removeReason(reasons, criteria, callback)`

Remove reasons from action’s metadata and remove actions without reasons.

Argument	Type	Description
`reasons`	`string[]`	The reason names.
`criteria`	`Criteria`	Criteria to select actions for reason removing.
`callback`	`ReadonlyListener`	Callback for every removed action.

Returns Promise. Promise when cleaning will be finished.

`LogStore#setLastSynced(values)`

Set added value for latest synchronized received or/and sent events.

Argument	Type	Description
`values`	`Partial<LastSynced>`	Object with latest sent or received values.

Returns Promise. Promise when values will be saved to store.

LoguxError

Extends Error.

Logux error in logs synchronization.

if (error.name === 'LoguxError') {
  console.log('Server throws: ' + error.description)
}

Parameter	Type	Description
`type`	`ErrorType`	The error code.
`options` ?	`LoguxErrorOptions[ErrorType]`	The error option.
`received` ?	`boolean`	Was error received from remote node.

`LoguxError.description(type, options?)`

Return a error description by it code.

Argument	Type	Description
`type`	`Type`	The error code.
`options` ?	`LoguxErrorOptions[Type]`	The errors options depends on error code.

Returns string.

`LoguxError#description`

Human-readable error description.

console.log('Server throws: ' + error.description)

Type: string.

`LoguxError#message`

Full text of error to print in debug message.

Type: string.

`LoguxError#name`

Always equal to LoguxError. The best way to check error class.

if (error.name === 'LoguxError') {

Type: "LoguxError".

`LoguxError#options`

Error options depends on error type.

if (error.type === 'timeout') {
  console.error('A timeout was reached (' + error.options + ' ms)')
}

Type: LoguxErrorOptions[ErrorType].

`LoguxError#received`

Was error received from remote client.

Type: boolean.

`LoguxError#stack`

Calls which cause the error.

Type: string.

`LoguxError#type`

The error code.

if (error.type === 'timeout') {
  fixNetwork()
}

Type: ErrorType.

`LoguxErrorOptions`

Property	Type
`bruteforce`	`void`
`timeout`	`number`
`unknown-message`	`string`
`wrong-credentials`	`void`
`wrong-format`	`string`
`wrong-protocol`	`Versions`
`wrong-subprotocol`	`Versions`

LoguxNotFoundError

Extends Error.

An error for load() callback to return logux/undo with 404.

import { LoguxNotFoundError } from '@logux/actions'

server.channel('posts/:id', {
  load () {
    throw new LoguxNotFoundError()
  },
  …
})

`LoguxNotFoundError#name`

Type: "LoguxNotFoundError".

`LoguxProcessedAction`

Property	Type
`id`	`string`
`type`	`"logux/processed"`

`LoguxSubscribeAction`

Property	Type
`channel`	`string`
`creating` ?	`true`
`filter` ?	`{ }`
`since` ?	`{ id: string, time: number }`
`type`	`"logux/subscribe"`

`LoguxSubscribedAction`

Property	Type
`channel`	`string`
`type`	`"logux/subscribed"`

`LoguxUndoAction`

Property	Type
`action`	`RevertedAction`
`id`	`string`
`reason`	`Reason`
`type`	`"logux/undo"`

LoguxUndoError

Extends Error.

Error on logux/undo action from the server.

try {
  client.sync(action)
} catch (e) {
  if (e.name === 'LoguxUndoError') {
    console.log(e.action.action.type ' was undid')
  }
}

Parameter	Type
`action`	`RevertedAction`

`LoguxUndoError#action`

Server logux/undo action. It has origin actions (which was undid) in action.action.

console.log(error.action.action.type ' was undid')

Type: RevertedAction.

`LoguxUndoError#name`

The better way to check error, than instanceof.

if (error.name === 'LoguxUndoError') {

Type: "LoguxUndoError".

`LoguxUnsubscribeAction`

Property	Type
`channel`	`string`
`filter` ?	`{ }`
`type`	`"logux/unsubscribe"`

`Message`

`Meta`

Property	Type	Description
`added`	`number`	Sequence number of action in current log. Log fills it.
`id`	`string`	Action unique ID. Log sets it automatically.
`indexes` ?	`string[]`	Indexes for action quick extraction.
`keepLast` ?	`string`	Set value to `reasons` and this reason from old action.
`reasons`	`string[]`	Why action should be kept in log. Action without reasons will be removed.
`subprotocol` ?	`number`	Application subprotocol version.
`time`	`number`	Action created time in current node time. Milliseconds since UNIX epoch.

`MetaTime`

Type: Pick<ClientMeta,"time" | "id">.

`NewCrdtRow`

Row accepted by CrdtTable#create: CrdtCreateFields with optional id, which will be generated if omitted.

Type: { id?: string } & CrdtCreateFields.

`NodeOptions`

Property	Type	Description
`auth` ?	`Authenticator`	Function to check client credentials.
`fixTime` ?	`boolean`	Detect difference between client and server and fix time in synchronized actions.
`onReceive` ?	`ActionFilter`	Function to filter or change actions coming from remote node’s before put it to current log.
`onSend` ?	`ActionFilter`	Function to filter or change actions before sending to remote node’s.
`ping` ?	`number`	Milliseconds since last message to test connection by sending ping.
`subprotocol` ?	`number`	Application subprotocol version.
`syncBatch` ?	`number`	Maximum actions in a single `sync` message. `100` by default. Node will split a bigger batch into a few messages, so the remote node will be able to apply them by parts.
`timeout` ?	`number`	Timeout in milliseconds to wait answer before disconnect.
`token` ?	`string \| TokenGenerator`	Client credentials. For example, access token.

`NodeState`

Type: "connecting" | "disconnected" | "sending" | "synchronized".

`OmitFromUnion`

Omit which is applied to each member of the union separately. It is necessary for actions with different shapes, like batch actions.

Type: Type ? Omit<Type,Keys> : never.

`PackedAction`

Property	Type
`action`	`ReducedAction`
`blob`	`Uint8Array`

`PersistentStorage`

Type: { [key: string]: string | undefined }.

`PreactErrorHandlers`

Property	Type
`AccessDenied` ?	`any`
`Error` ?	`any`
`NotFound` ?	`any`

`PreaddListener(action, meta)`

Argument	Type
`action`	`ListenerAction`
`meta`	`LogMeta`

`PrepareForTest(client, Template, value)`

Argument	Type
`client`	`Client`
`Template`	`SyncMapTemplateLike`
`value`	`{ id?: string } & Omit<Value,"id">`

Argument	Type
`client`	`Client`
`Template`	`SyncMapTemplate`
`value`	`{ id?: string } & Omit<Value,"id">`

Returns MapStore<Value>.

`ReactErrorHandlers`

Property	Type
`AccessDenied` ?	`any`
`Error` ?	`any`
`NotFound` ?	`any`

`ReadonlyListener(action, meta)`

Argument	Type
`action`	`ListenerAction`
`meta`	`LogMeta`

`ReconnectOptions`

Property	Type	Description
`attempts` ?	`number`	Maximum reconnecting attempts.
`maxDelay` ?	`number`	Maximum delay between re-connecting.
`minDelay` ?	`number`	Minimum delay between re-connecting.

`Reducer`

Property	Type	Description
`ready`	`Promise`	Promise resolved when the data was prepared and all actions from the log were reduced.
`status`	`ReadableAtom`
`destroy`	`() => void`
`type`	`(type: TypeAction["type"], listener: ActionListener) => void`

`ReducerInitCallbacks`

Property	Type	Description
`storage` ?	`PersistentStorage`	Storage to keep the reducer’s version instead of `localStorage` (for instance, for React Native or tests).
`clean`	`(oldVersion: number) => void \| [Action, MetaTime][] \| Promise \| Promise<[Action, MetaTime][]>`
`init` ?	`() => void \| Promise`
`migrating` ?	`(done: Promise) => void`
`stop` ?	`() => void`

`ReducerMigrationStatus`

Type: "initializing" | "migrating" | "outdated" | "ready".

`RequestOptions`

Property	Type	Description
`allowDangerousProtocol` ?	`boolean`	Do not show warning when using `ws://` in production.
`attempts` ?	`number`	Maximum reconnection attempts. Default is `Infinity`.
`maxDelay` ?	`number`	Maximum delay between reconnections. Default is `5000`.
`minDelay` ?	`number`	Minimum delay between reconnections. Default is `1000`.
`ping` ?	`number`	Milliseconds since last message to test connection by sending ping. Default is `10000`.
`prefix` ?	`string`	Prefix for `IndexedDB` database to run multiple Logux instances in the same browser. Default is `logux`.
`server`	`any`	Server URL.
`store` ?	`any`	Store to save log data. Default is `MemoryStore`.
`subprotocol`	`number`	Client subprotocol version.
`time` ?	`any`	Test time to test client.
`timeout` ?	`number`	Timeout in milliseconds to break connection. Default is `70000`.
`token` ?	`any`	Client credentials for authentication.
`userId` ?	`string`

`ShadowAction`

Property	Type
`id`	`string`
`type`	`"shadow"`

SqlLogStore

Extends unknown.

SQL store for Logux log on top of @nanostores/sql database.

It works with any driver of @nanostores/sql: SQLite in the browser by SQLocal, PGlite, Expo SQLite in React Native, or Node.js SQLite in tests.

import { CrossTabClient } from '@logux/client'
import { SqlLogStore } from '@logux/client/db'
import { openDb } from '@nanostores/sql'
import { sqlocalDriver } from '@nanostores/sql/sqlocal'

const db = openDb(sqlocalDriver('app.sqlite'))
const client = new CrossTabClient({
  …,
  store: new SqlLogStore(db)
})

The store keeps actions in logux_log, logux_reason, logux_index, and logux_extra tables. They will be created on the first query.

Version of the tables format is kept in logux_version table. If the database was created by a newer version of the client, all methods will throw an error.

Parameter	Type	Description
`db`	`Database`	Database from `@nanostores/sql` `openDb()`.
`opts` ?	`SqlLogStoreOptions`	Store options.

`SqlLogStore#onTransactionAdd(callback)`

Set the callback, which will be called inside the transaction writing the action to the log. It allows to apply the action to the tables of the same database atomically: the action and its result will be committed together, and await of log.add() will mean that the tables were already changed.

createCrdtDatabase sets it automatically, if the log and the CRDT tables are in the same database.

An error in the callback rolls back the whole transaction, so the action will not be added to the log.

Argument	Type	Description
`callback`	`(tx: Database, action: AnyAction, meta: ClientMeta) => void \| Promise \| undefined`	Callback or `undefined` to remove the previous one.

`SqlLogStoreOptions`

Property	Type	Description
`packers` ?	`Packers`	Packers to keep the binary parts of the actions in a separate column instead of Base64 inside the JSON.

`StatusListener(current, details)`

Argument	Type
`current`	`StatusValue`
`details`	`{ action: LoguxUndoAction, meta: ClientMeta } \| { error: Error } \| undefined`

`StatusOptions`

Property	Type	Description
`duration` ?	`number`	Synchronized state duration. Default is `3000`.

`StatusValue`

`StorageActionListener(prevValue, action, meta)`

Argument	Type
`prevValue`	`Value`
`action`	`ListenAction`
`meta`	`any`

Returns Value | Promise<Value>.

`StorageCallbacks`

Property	Type	Description
`storage` ?	`PersistentStorage`	Storage to keep the value and the reducer’s version instead of `localStorage` (for instance, for React Native or tests).
`migrating` ?	`(done: Promise) => void`
`repeat`	`() => [Action, MetaTime][] \| Promise<[Action, MetaTime][]>`

`StorageReducer`

Property	Type	Description
`ready`	`Promise`	Promise resolved when the value was loaded and all actions from the log were reduced. It is also resolved when the reducer became `outdated`.
`status`	`ReadableAtom`
`value`	`ReadableAtom`	The reduced value.
`destroy`	`() => void`
`type`	`(type: TypeAction["type"], listener: StorageActionListener) => void`

`SyncMapChangeAction`

Property	Type
`fields`	`Partial<Omit<Value,"id">>`
`id`	`string`
`type`	`string`

`SyncMapChangedAction`

Property	Type
`fields`	`Partial<Omit<Value,"id">>`
`id`	`string`
`type`	`string`

`SyncMapCreateAction`

Property	Type
`fields`	`Omit<Value,"id">`
`id`	`string`
`type`	`string`

`SyncMapCreatedAction`

Property	Type
`fields`	`Omit<Value,"id">`
`id`	`string`
`type`	`string`

`SyncMapDeleteAction`

Property	Type
`id`	`string`
`type`	`string`

`SyncMapDeletedAction`

Property	Type
`id`	`string`
`type`	`string`

`SyncMapStore`

Type: MapStore<SyncMapValue> & SyncMapStoreExt.

`SyncMapStoreExt`

Property	Type	Description
`client`	`Client`	Logux Client instance.
`createdAt` ?	`any`	Meta from create action if the store was created locally.
`deleted` ?	`true`	Mark that store was deleted.
`loading`	`Promise`	While store is loading initial data from server or log.
`offline`	`boolean`	Does store keep data in the log after store is destroyed.
`plural`	`string`	Name of map class.
`remote`	`boolean`	Does store use server to load and save data.

`SyncMapTemplate(id, client, args)`

Argument	Type
`id`	`string`
`client`	`Client`
`args`	`[] \| [Action, ClientMeta, boolean \| undefined]`

Returns any.

`SyncMapTemplate#cache`

Type: { }.

`SyncMapTemplate#offline`

Type: boolean.

`SyncMapTemplate#plural`

Type: string.

`SyncMapTemplate#remote`

Type: boolean.

`SyncMapTemplateLike(id, client, args)`

Argument	Type
`id`	`string`
`client`	`Client`
`args`	`Args`

Returns MapStore<Value>.

`SyncMapTypes`

Type: boolean | null | number | string | undefined.

`SyncMapValue`

Type: { id: string, isLoading: true } | LoadedSyncMapValue.

`SyncMapValues`

`SyncMeta`

Property	Type
`id`	`string`
`subprotocol` ?	`number`
`time`	`number`

`TabID`

Type: string.

`TestClientOptions`

Property	Type
`headers` ?	`Headers`
`server` ?	`TestServer`
`subprotocol` ?	`number`

`TestLogOptions`

Property	Type	Description
`nodeId` ?	`string`	Unique log name.
`store` ?	`LogStore`	Store for log. Will use `MemoryStore` by default.

`TokenGenerator()`

Returns string | Promise<string>.

`Versions`

Property	Type
`supported`	`number`
`used`	`number`

`WithoutMeta`

Row without conflict resolution data of every field.

Type: { [Key: keyof Value]: Value[Key] }.

WsBinaryConnection

Extends WsConnection.

Logux connection for WebSocket using binary protocol.

Automatically detects text-based peers and falls back to JSON encoding, so it can be used in ServerConnection to handle both binary and text clients.

import { WsBinaryConnection } from '@logux/core'

const connection = new WsBinaryConnection('wss://logux.example.com/')
const node = new ClientNode(nodeId, log, connection, opts)

Parameter	Type	Description
`url`	`string`	WebSocket server URL.
`Class` ?	`unknown`
`opts` ?	`unknown`	Extra option for WebSocket constructor.

`WsBinaryConnection#connected`

Is connection is enabled.

Type: boolean.

`WsBinaryConnection#destroy`

Disconnect and unbind all even listeners.

Type: () => void.

`WsBinaryConnection#textMode`

Whether to use text JSON protocol instead of binary. Always true for WsConnection, can change in WsBinaryConnection.

Type: boolean.

`WsBinaryConnection#ws`

WebSocket instance.

Type: WS.

`WsBinaryConnection#connect()`

Start connection. Connection should be in disconnected state from the beginning and start connection only on this method call.

This method could be called again if connection moved to disconnected state.

Returns Promise. Promise until connection will be established.

`WsBinaryConnection#disconnect(reason?)`

Finish current connection.

Argument	Type	Description
`reason` ?	`"destroy" \| "error" \| "timeout"`	Disconnection reason.

`WsBinaryConnection#on(event, listener)`

Argument	Type
`event`	`"disconnect"`
`listener`	`(reason: string) => void`

Argument	Type
`event`	`"error"`
`listener`	`(error: Error) => void`

Argument	Type	Description
`event`	`"connect" \| "connecting" \| "disconnect"`	Event name.
`listener`	`() => void`	Event listener.

Argument	Type
`event`	`"message"`
`listener`	`(msg: Message) => void`

Returns Unsubscribe.

`WsBinaryConnection#send(message)`

Send message to connection.

Argument	Type	Description
`message`	`Message`	The message to be sent.

WsConnection

Extends Connection.

Logux connection for WebSocket.

import { WsConnection } from '@logux/core'

const connection = new WsConnection('wss://logux.example.com/')
const node = new ClientNode(nodeId, log, connection, opts)

Parameter	Type	Description
`url`	`string`	WebSocket server URL.
`Class` ?	`unknown`
`opts` ?	`unknown`	Extra option for WebSocket constructor.

`WsConnection#connected`

Is connection is enabled.

Type: boolean.

`WsConnection#destroy`

Disconnect and unbind all even listeners.

Type: () => void.

`WsConnection#textMode`

Whether to use text JSON protocol instead of binary. Always true for WsConnection, can change in WsBinaryConnection.

Type: boolean.

`WsConnection#ws`

WebSocket instance.

Type: WS.

`WsConnection#connect()`

Start connection. Connection should be in disconnected state from the beginning and start connection only on this method call.

This method could be called again if connection moved to disconnected state.

Returns Promise. Promise until connection will be established.

`WsConnection#disconnect(reason?)`

Finish current connection.

Argument	Type	Description
`reason` ?	`"destroy" \| "error" \| "timeout"`	Disconnection reason.

`WsConnection#on(event, listener)`

Argument	Type
`event`	`"disconnect"`
`listener`	`(reason: string) => void`

Argument	Type
`event`	`"error"`
`listener`	`(error: Error) => void`

Argument	Type	Description
`event`	`"connect" \| "connecting" \| "disconnect"`	Event name.
`listener`	`() => void`	Event listener.

Argument	Type
`event`	`"message"`
`listener`	`(msg: Message) => void`

Returns Unsubscribe.

`WsConnection#send(message)`

Send message to connection.

Argument	Type	Description
`message`	`Message`	The message to be sent.

`ZeroAction`

Property	Type
`compressed`	`boolean`
`d`	`Uint8Array`
`iv`	`Uint8Array`
`type`	`"0"`

`ZeroCleanAction`

Type: { type: "0/clean" } & { id: string } | { ids: string[] }.

`actionEvents(emitter, event, action, meta)`

Argument	Type
`emitter`	`Emitter`
`event`	`"add" \| "clean" \| "preadd"`
`action`	`Action`
`meta`	`ClientMeta`

`badgeEn`

English translation for widget.

Type: BadgeMessages.

`badgeRu`

Russian translation for widget.

Type: BadgeMessages.

`badgeStyles`

Type: BadgeStyles.

`bigint(opts?)`

BIGINT column with number value. Use it for timestamps as a number of milliseconds — the same format as dates in Logux actions:

import { bigint } from '@logux/client/db'

let schema = {
  createdAt: bigint({ default: () => Date.now() }),
  publishedAt: optional(bigint())
}

Argument	Type	Description
`opts` ?	`string \| Omit<CrdtColumnOptions,"default">`	Extra column definition SQL or column options.

Argument	Type	Description
`opts`	`{ default: () => NoInfer \| NoInfer } & CrdtColumnOptions`	Extra column definition SQL or column options.

Returns { type: "BIGINT" } & CrdtColumn.

`boolean(opts?)`

BOOLEAN column for databases with native boolean support like PGlite. SQLite has no boolean type, so with 'sqlite' dialect use number column with 1/0 instead (using this builder there is a type error and throws in CrdtDatabase#table).

Argument	Type	Description
`opts` ?	`string \| Omit<CrdtColumnOptions,"default">`	Extra column definition SQL or column options.

Argument	Type	Description
`opts`	`{ default: boolean \| () => boolean } & CrdtColumnOptions`	Extra column definition SQL or column options.

Returns { type: "BOOLEAN" } & CrdtColumn.

`crdtTableToActions(tables)`

Restore actions from the tables.

The oldest restored action of a row is plural/created, the rest are plural/changed. Rows changed by one batch action are restored as a single batch action.

let crdt = createCrdtDatabase(client, db, {
  repeat: () => crdtTableToActions([user, post])
})

Argument	Type	Description
`tables`	`Pick<CrdtTable,"driver" \| "plural" \| "schema">[]`	Tables of `CrdtDatabase#table` to read.

Returns Promise<[Action, MetaTime][]>. Actions with restored meta id and time, oldest first.

`createAuth(client)`

Create store with user’s authentication state.

import { createAuth } from '@logux/client'

let auth = createAuth(client)
await auth.loading
console.log(auth.get())

Argument	Type	Description
`client`	`Client`	Logux Client.

Returns AuthStore.

`createClientStore`

Type: CreateClientStore.

`createCrdtDatabase(client, db, opts?)`

Create CRDT LWW Map tables on top of SQL database filled from Logux log.

Tables are filled by reducing actions from the log (like createReducer). CrdtTable#create, CrdtTable#update and CrdtTable#delete add actions to the log, and the reducer applies them to the database. Their promises are resolved only after the tables were changed, so the next CrdtTable#select will already see the change. They are rejected if applying failed or if the database was stopped before it.

Until the action is applied, it is kept in the log by the applying-to-db reason. Any tab can take the key:apply lock, apply the actions in batches, and remove the reason. Actions of the tab, which was closed in the middle of the work, will be applied on the next start.

Actions are the same as in syncMapTemplate (user/created, user/changed, user/deleted from @logux/actions), so tables are compatible with existing Logux servers and can be mixed with syncMapTemplate stores on other clients. Arrays in CrdtTable#create, CrdtTable#update and CrdtTable#delete produce batch actions (with records or ids instead of id), which are applied to the database in a single query.

Each table has an extra id column and an updatedAt_field column for every field with the Logux Meta ID of its last change, to resolve edit conflicts with per-field last write wins strategy.

The schema version — serialized schemas and indexes of all tables — is kept in the logux_crdt table of the database itself and is copied to localStorage (or to CrdtDatabaseOptions#storage) to tell other tabs about the change. On any schema change all tables (including tables removed from the schema) are dropped and refilled by replaying actions from the log and from the repeat() callback.

While there are actions waiting to be applied to the database, the tab asks the user to confirm closing. It only saves the user from waiting for the next start: it guarantees nothing, since the browser can close the tab without asking, and the actions are not lost anyway.

import { openDb, sqlocalDriver } from '@nanostores/sql'
import {
  bigint, createCrdtDatabase, number, oneOf, optional, string
} from '@logux/client/db'

let db = openDb(sqlocalDriver('app.sqlite'))
let crdt = createCrdtDatabase(client, db, {
  async repeat() {
    return await fetchActionsSnapshot()
  }
})

crdt.on('migrating', done => {
  showLoader('Migrating database', done)
})
crdt.on('stop', () => {
  updateAppWarning.show()
})

showLoader('Loading data', crdt.ready)

let user = crdt.table(
  'user',
  {
    age: optional(number()),
    createdAt: bigint({ default: () => Date.now() }),
    email: string('COLLATE NOCASE'),
    isAdmin: number({ default: 0 }),
    name: string(),
    theme: oneOf(['dark', 'light'], { default: 'dark' })
  },
  [{ columns: ['email'], unique: true }, ['isAdmin', 'name']]
)

let id = await user.create({ email: 'ann@example.com', name: 'Ann' })
await user.update(id, { age: 30 })
let $admins = user.select`WHERE "isAdmin" = ${1} ORDER BY "name"`
await user.delete(id)

Argument	Type	Description
`client`	`Client`	Logux client.
`db`	`Database`	SQL database from `@nanostores/sql` `openDb()`.
`opts` ?	`CrdtDatabaseOptions`	Database options and the source of old actions.

Returns CrdtDatabase.

`createCrdtTasks(crdt, opts?)`

Queue for the log writes of the database bookkeeping.

The applied listener runs inside the applying transaction, so it can not await a log write: the store will put the write in its own transaction, which waits for the applying one to commit. The migration replay opens its transactions the same way.

The queue solves both: the tasks are not awaited by the applier, they are serialized between themselves, so they do not overwrite each other’s changes, and they start only after CrdtDatabase#ready.

import { createCrdtTasks } from '@logux/client/db'

let tasks = createCrdtTasks(crdt)

crdt.on('applied', (tx, action, meta, won) => {
  tasks.add(async () => {
    await client.log.removeReason(
      won.map(cell => cell.join('/')),
      { olderThan: meta }
    )
  })
})

Argument	Type	Description
`crdt`	`Pick<CrdtDatabase,"ready">`	CRDT database from `createCrdtDatabase`.
`opts` ?	`CrdtTasksOptions`	Queue options.

Returns CrdtTasks. Task queue.

`createReducer(client, name, version, callbacks)`

Create long-term persistent Logux actions reducer. It can be used to store Logux data in WASM sqlite or localStorage.

Only one browser tab will reduce the log.

The reducer’s version is removed on Client#clean, since the value is not re-created from the log on the next start. Reducers with their own storage should subscribe to the cleaning event to remove the data itself.

import { createReducer } from '@logux/client'

let db = sqlite.openDatabase('database.sqlite')
createReducer(client, 'db', 10, {
  async clean() {
    await db.close()
    await sqlite.removeFile('database.sqlite')
  },
  async init() {
    db.query('CREATE TABLE users …')
  },
  migrating(done) {
    showLoader('Migrating data', done)
  },
  stop() {
    db.close()
    updateAppWarning.show()
  }
})
  .type('users/create', async action => {
    await db.query(`INSERT INTO users …`)
  })

Argument	Type	Description
`client`	`Client`	Logux client.
`name`	`string`	The name of the reducer to use in the storage version key.
`version`	`number`	The current version to call migrations on new version.
`callbacks`	`ReducerInitCallbacks`	The data migrations callbacks.

Returns Reducer.

`createStorageReducer(client, name, version, initialValue, callbacks)`

Create a reducer that reduces actions into a single value stored in localStorage (or in StorageCallbacks#storage). The value is loaded on first run and kept in sync across tabs via storage events.

The value is removed on Client#clean together with the log.

import { createStorageReducer } from '@logux/client'

let counter = createStorageReducer(client, 'counter', 1, 0, {
  decode: s => parseInt(s, 10),
  encode: v => String(v),
  repeat() {
    return client.log.each(action => action.type === 'inc')
  }
})
counter.type<{ type: 'inc' }>('inc', prev => prev + 1)

Argument	Type
`client`	`Client`
`name`	`string`
`version`	`number`
`initialValue`	`NoInfer`
`callbacks`	`StorageCallbacks`

Argument	Type
`client`	`Client`
`name`	`string`
`version`	`number`
`initialValue`	`Value`
`callbacks`	`StorageCallbacks & Convertor`

Returns StorageReducer.

`defineChangedCrdtTable(table)`

Argument	Type
`table`	`AbstractCrdtTable`

Returns ActionCreator.

`defineChangedSyncMap(plural)`

Argument	Type
`plural`	`string`

Returns ActionCreator.

`defineChangeSyncMap(plural)`

Argument	Type
`plural`	`string`

Returns ActionCreator.

`defineCrdtTableActions(table)`

Returns created/changed/deleted action creators for a CRDT table. Column types are extracted from the table and put into the action fields types.

import { defineCrdtTableActions } from '@logux/actions'

const user = crdt.table('user', { name: string(), age: optional(number()) })

const [
  createdUserAction,
  changedUserAction,
  deletedUserAction
] = defineCrdtTableActions(user)

Argument	Type
`table`	`AbstractCrdtTable`

Returns [ActionCreator, ActionCreator, ActionCreator].

`defineCreatedCrdtTable(table)`

Argument	Type
`table`	`AbstractCrdtTable`

Returns ActionCreator.

`defineCreatedSyncMap(plural)`

Argument	Type
`plural`	`string`

Returns ActionCreator.

`defineCreateSyncMap(plural)`

Argument	Type
`plural`	`string`

Returns ActionCreator.

`defineDeletedCrdtTable(table)`

Argument	Type
`table`	`AbstractCrdtTable`

Returns ActionCreator.

`defineDeletedSyncMap(plural)`

Argument	Type
`plural`	`string`

Returns ActionCreator.

`defineDeleteSyncMap(plural)`

Argument	Type
`plural`	`string`

Returns ActionCreator.

`defineSyncMapActions(plural)`

Returns actions for CRDT Map.

import { defineSyncMapActions } from '@logux/actions'

const [
  createUserAction,
  changeUserAction,
  deleteUserAction,
  createdUserAction,
  changedUserAction,
  deletedUserAction
] = defineSyncMapActions('users')

Argument	Type
`plural`	`string`

Returns [ActionCreator, ActionCreator, ActionCreator].

`eachStoreCheck(test)`

Pass all common tests for Logux store to callback.

import { eachStoreCheck } from '@logux/core'

eachStoreCheck((desc, creator) => {
  it(desc, creator(() => new CustomStore()))
})

Argument	Type	Description
`test`	`(name: string, testCreator: (storeCreator: () => LogStore) => () => void) => void`	Callback to create tests in your test framework.

`ensureLoaded(value)`

Change store’s value type to value with isLoaded: false.

If store is still loading, this function will trow an error.

Use it for tests written on TypeScript.

import { ensureLoaded } from '@logux/client'

expect(ensureLoaded($currentUser)).toEqual({ id: 1, name: 'User' })

Argument	Type	Description
`value`	`SyncMapValue`	Store’s value.

Argument	Type	Description
`value`	`FilterValue`	Store’s value.

Returns LoadedSyncMapValue.

`ensureLoadedStore(store)`

Argument	Type
`store`	`Store`

Returns any.

`fake-indexeddb`

`fake-indexeddb/lib/FDBKeyRange`

`fromCompat(str)`

Decode number from -0-9A-Z_a-z alphabet.

fromCompat('OzcVoWD') //=> 1786312345678

Argument	Type	Description
`str`	`string`	Encoded number.

Returns number. Decoded number.

`getRandomSpaces()`

Returns string.

`idToTime(id)`

Decode meta.time from action ID.

idToTime('OzcVoWD client:1') //=> 1786312345678

Argument	Type	Description
`id`	`string`	Action ID or its time part.

Returns number. Milliseconds since UNIX epoch.

`isSameClient(id, clientId)`

Faster alternative for parseId(meta.id).clientId === clientId check.

It doesn’t create any object or string during the check.

import { isSameClient } from '@logux/core'
if (isSameClient(meta.id, ctx.clientId)) {
  // Action was created by this client
}

Argument	Type	Description
`id`	`string`	Action or Node ID
`clientId`	`string`	Client ID to compare with

Returns boolean.

`loadValue(store)`

Return store’s value if store is loaded or wait until store will be loaded and return its value.

Returns undefined on 404.

import { loadValue } from '@logux/client'

let user = loadValue($currentUser)

Argument	Type	Description
`store`	`Store`	Store to load.

Argument	Type	Description
`store`	`Store`	Store to load.

Returns Promise<any>.

`loguxProcessed`

Returns logux/processed action.

Type: ActionCreator.

`loguxSubscribe`

Returns logux/subscribe action.

Type: ActionCreator.

`loguxSubscribed`

Returns logux/subscribed action.

Type: ActionCreator.

`loguxUndo(fields)`

Returns logux/undo action.

Argument	Type
`fields`	`{ action: RevertedAction, id: string, reason: Reason }`

Returns LoguxUndoAction.

`loguxUnsubscribe`

Returns logux/unsubscribe action.

Type: ActionCreator.

`number(opts?)`

DOUBLE PRECISION column with number value.

Argument	Type	Description
`opts` ?	`string \| Omit<CrdtColumnOptions,"default">`	Extra column definition SQL or column options.

Argument	Type	Description
`opts`	`{ default: NoInfer } & CrdtColumnOptions`	Extra column definition SQL or column options.

Returns { type: "DOUBLE PRECISION" } & CrdtColumn.

`oneOf(values, opts?)`

Enum column with union of string values. Stored as TEXT with CHECK constraint.

import { oneOf } from '@logux/client/db'

let schema = {
  role: oneOf(['admin', 'guest', 'user'], { default: 'user' }),
  theme: oneOf(['dark', 'light'])
}

Argument	Type	Description
`values`	`Values`	Allowed string values.
`opts` ?	`string \| Omit<CrdtColumnOptions,"default">`	Extra column definition SQL or column options.

Argument	Type	Description
`values`	`Values`	Allowed string values.
`opts`	`{ default: () => Values[number] \| Values[number] } & CrdtColumnOptions`	Extra column definition SQL or column options.

Returns { type: "TEXT" } & CrdtColumn.

`optional(column)`

Mark column as optional. The field can be omitted or set to null in CrdtTable#create, can be set to null in CrdtTable#update to clear the value, and is null (SQL NULL) in rows when missing.

import { number, optional } from '@logux/client'

let schema = {
  age: optional(number())
}

Argument	Type	Description
`column`	`Column`	Column definition to wrap.

Returns { type: Column["type"] } & CrdtColumn.

`parseCrdtAction(action, crdt)`

Read the rows and fields of a table action, whatever batch shape it uses (records, ids or a single id).

Policies on the applied event and on the log events need it to know, which rows the action is about, before it was applied.

import { parseCrdtAction } from '@logux/client/db'

client.on('preadd', (action, meta) => {
  let parsed = parseCrdtAction(action, crdt)
  if (!parsed) return
  for (let [id, fields] of parsed.rows) {
    for (let field of fields) {
      meta.reasons.push(`${parsed.plural}/${id}/${field}`)
    }
  }
})

The schemas can be written by hand, so actions can be parsed without the database (in tests or on the server):

parseCrdtAction(action, { tables: { feeds: feedsSchema } })

Argument	Type	Description
`action`	`Action`	Any action from the log.
`crdt`	`Pick<CrdtDatabase,"tables">`	Database from `createCrdtDatabase` or any object with `CrdtDatabase#tables` to parse actions without the database.

Returns false | CrdtParsedAction. Parsed action or false if it is not an action of these tables.

`parseCrdtRows(action)`

Split a table action into rows, whatever batch shape it uses (records, ids or a single id). The single place, which knows the shapes: re-implementing them in the app will break on the next shape added here.

The fields are the action’s own values without any check, so the caller must filter them by the table schema: the fields of a records row also contain id, and a plural/deleted action has no fields at all. Use parseCrdtAction to get the field names of the schema instead.

The action type is not checked, so call it only for actions of CrdtDatabase#table.

import { parseCrdtRows } from '@logux/client/db'

for (let [id, fields] of parseCrdtRows(action)) {
  await copyToBackup(id, fields)
}

Argument	Type	Description
`action`	`Action`	Table action.

Returns [id: string, fields: object][]. Row IDs with the fields, which the action writes to them.

`parseCrdtType(type, crdt)`

Read the table and the verb of the action type, if the action belongs to one of the tables.

Use it when the rows are not necessary, for instance, to find the actions of deleted rows in the log.

import { parseCrdtType } from '@logux/client/db'

client.log.on('clean', action => {
  let parsed = parseCrdtType(action.type, crdt)
  if (parsed?.verb === 'deleted') cleaned.add(parsed.plural)
})

Argument	Type	Description
`type`	`string`	Type of any action from the log.
`crdt`	`Pick<CrdtDatabase,"tables">`	Database from `createCrdtDatabase` or any object with `CrdtDatabase#tables` to parse actions without the database.

Returns false | CrdtParsedType. Table and verb or false if it is not an action of these tables.

`replaceWithShadow(client, meta)`

Add shadow action to the log. It is useful for client to clean server from encrypted zero actions.

It replaces materialized action in the log, keeping its ID, reasons and indexes, but dropping the body.

By tracking shadow reasons you can detect when you can ask server to remove original action.

import { shadow, zeroClean } from '@logux/actions'
import { replaceWithShadow } from '@logux/client'

client.log.type('logux/processed', async processed => {
  let [action, meta] = await client.log.byId(processed.id)
  if (action) await replaceWithShadow(client, meta)
})

client.log.on('clean', action => {
  if (shadow.match(action)) {
    client.log.add(zeroClean({ ids: [action.id] }), { sync: true })
  }
})

Argument	Type	Description
`client`	`Client`	Logux Client.
`meta`	`ClientMeta`	Meta of the original action.

Returns Promise<ClientMeta>. Meta of the added shadow action.

`shadow`

Returns shadow action. It is useful for client to clean server from encrypted zero actions.

It replaces materialized action in the log, keeping its ID, reasons and indexes, but dropping the body.

By tracking shadow reasons you can detect when you can ask server to remove original action.

Type: ActionCreator.

`sortedToMeta(sorted)`

Convert string created by toSorted() back to metadata.

sortedToMeta('------Ec test ------Ec') //=> { id: 'Ec test', time: 1000 }

Argument	Type	Description
`sorted`	`string`	String created by `toSorted()`.

Returns MetaTime. Action’s metadata with id and time keys.

`status(client, callback, options?)`

Low-level function to show Logux synchronization status with your custom UI. It is used in badge widget.

import { status } from '@logux/client'
status(client, current => {
  updateUI(current)
})

Argument	Type	Description
`client`	`Client`	Observed Client instance.
`callback`	`StatusListener`
`options` ?	`StatusOptions`

Returns () => void. Unbind listener.

`string(opts?)`

TEXT column with string value.

import { string } from '@logux/client'

let schema = {
  email: string('COLLATE NOCASE'),
  name: string(),
  theme: string<'dark' | 'light'>({ default: 'dark' })
}

Argument	Type	Description
`opts` ?	`string \| Omit<CrdtColumnOptions,"default">`	Extra column definition SQL or column options.

Argument	Type	Description
`opts`	`{ default: NoInfer } & CrdtColumnOptions`	Extra column definition SQL or column options.

Returns { type: "TEXT" } & CrdtColumn.

`toCompat(number)`

Encode number to -0-9A-Z_a-z alphabet.

Chars are in ASCII order, so strings of the same length have the same order as encoded numbers.

toCompat(64) //=> "0-"

Argument	Type	Description
`number`	`number`	Number to encode.

Returns string. Encoded number.

`toSorted(meta)`

Convert metadata to a string with the same order as isFirstOlder().

Numbers are padded, so simple string sorting (for instance, in a database column) will return actions in the log order.

db.insert({ action, sorted: toSorted(meta) })
// SELECT * FROM actions ORDER BY sorted

Argument	Type	Description
`meta`	`MetaTime`	Action’s metadata.

Returns string. String to sort actions.

`track(client, id)`

Track for logux/processed or logux/undo answer from server for the cases when Client#sync can’t be used.

client.type('pay', (action, meta) => {
  track(client, id).then(() => {
    console.log('paid')
  }).catch(() => {
    console.log('unpaid')
  })
})

Argument	Type	Description
`client`	`any`	Logux Client.
`id`	`ID`	Action ID.

Returns Promise. Promise when action was proccessed.

`withMeta(row)`

Add empty conflict resolution data to a row built in tests, so it could be compared with rows from CrdtTable#select.

expect(await loadList(user.select())).toEqual([
  withMeta<UserValue>({ id: 'U1', name: 'Ann' })
])

Argument	Type	Description
`row`	`WithoutMeta`	Row without `updatedAt_field` columns.

Returns Value. Row with null in updatedAt_field column of every field.

`withoutMeta(rows)`

Remove conflict resolution data, which is local and should not be in the backup or in tests expectations.

expect(withoutMeta(await loadList(user.select()))).toEqual([
  { id: 'U1', name: 'Ann' }
])

Argument	Type	Description
`rows`	`Value[]`	Rows from `CrdtTable#select`.

Returns WithoutMeta[]. Rows without updatedAt_field columns.