@livestore/common 0.3.0-dev.11 → 0.3.0-dev.13

package/src/schema/MutationEvent.ts

@@ -10,7 +10,7 @@ export type MutationEventPartial<TMutationsDef extends MutationDef.Any> = {
   args: Schema.Schema.Type<TMutationsDef['schema']>
 }
 
-export type MutationEventPartialEncoded<TMutationsDef extends MutationDef.Any> = {
+export type PartialEncoded<TMutationsDef extends MutationDef.Any> = {
   mutation: TMutationsDef['name']
   args: Schema.Schema.Encoded<TMutationsDef['schema']>
 }
@@ -20,6 +20,8 @@ export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
   args: Schema.Schema.Type<TMutationsDef['schema']>
   id: EventId.EventId
   parentId: EventId.EventId
+  clientId: string
+  sessionId: string | undefined
 }
 
 export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
@@ -27,6 +29,8 @@ export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
   args: Schema.Schema.Encoded<TMutationsDef['schema']>
   id: EventId.EventId
   parentId: EventId.EventId
+  clientId: string
+  sessionId: string | undefined
 }
 
 export type AnyDecoded = MutationEvent<MutationDef.Any>
@@ -35,6 +39,8 @@ export const AnyDecoded = Schema.Struct({
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
+  clientId: Schema.String,
+  sessionId: Schema.UndefinedOr(Schema.String),
 }).annotations({ title: 'MutationEvent.AnyDecoded' })
 
 export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
@@ -43,6 +49,8 @@ export const AnyEncoded = Schema.Struct({
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
+  clientId: Schema.String,
+  sessionId: Schema.UndefinedOr(Schema.String),
 }).annotations({ title: 'MutationEvent.AnyEncoded' })
 
 export const AnyEncodedGlobal = Schema.Struct({
@@ -50,11 +58,17 @@ export const AnyEncodedGlobal = Schema.Struct({
   args: Schema.Any,
   id: EventId.GlobalEventId,
   parentId: EventId.GlobalEventId,
+  clientId: Schema.String,
 }).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
 export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
 
 export type PartialAnyDecoded = MutationEventPartial<MutationDef.Any>
-export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
+export type PartialAnyEncoded = PartialEncoded<MutationDef.Any>
+
+export const PartialAnyEncoded = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+})
 
 export type PartialForSchema<TSchema extends LiveStoreSchema> = {
   [K in keyof TSchema['_MutationDefMapType']]: MutationEventPartial<TSchema['_MutationDefMapType'][K]>
@@ -75,6 +89,8 @@ export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord>
       args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
       id: EventId.EventId
       parentId: EventId.EventId
+      clientId: string
+      sessionId: string | undefined
     }
   }[keyof TMutationsDefRecord],
   {
@@ -83,6 +99,8 @@ export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord>
       args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
       id: EventId.EventId
       parentId: EventId.EventId
+      clientId: string
+      sessionId: string | undefined
     }
   }[keyof TMutationsDefRecord]
 >
@@ -112,6 +130,8 @@ export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
         args: def.schema,
         id: EventId.EventId,
         parentId: EventId.EventId,
+        clientId: Schema.String,
+        sessionId: Schema.UndefinedOr(Schema.String),
       }),
     ),
   ).annotations({ title: 'MutationEvent' }) as any
@@ -136,6 +156,8 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
+  clientId: Schema.String,
+  sessionId: Schema.UndefinedOr(Schema.String),
   // TODO get rid of `meta` again by cleaning up the usage implementations
   meta: Schema.optionalWith(
     Schema.Any as Schema.Schema<{
@@ -149,7 +171,7 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
     // - More readable way to print the id + parentId
     // - not including `meta`
     return {
-      id: `(${this.id.global},${this.id.local}) → (${this.parentId.global},${this.parentId.local})`,
+      id: `(${this.id.global},${this.id.client}) → (${this.parentId.global},${this.parentId.client})`,
       mutation: this.mutation,
       args: this.args,
     }
@@ -164,8 +186,9 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
   static fromGlobal = (mutationEvent: AnyEncodedGlobal) =>
     new EncodedWithMeta({
       ...mutationEvent,
-      id: { global: mutationEvent.id, local: EventId.localDefault },
-      parentId: { global: mutationEvent.parentId, local: EventId.localDefault },
+      id: { global: mutationEvent.id, client: EventId.clientDefault },
+      parentId: { global: mutationEvent.parentId, client: EventId.clientDefault },
+      sessionId: undefined,
     })
 
   toGlobal = (): AnyEncodedGlobal => ({
@@ -177,7 +200,9 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
 
 export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>
   a.id.global === b.id.global &&
-  a.id.local === b.id.local &&
+  a.id.client === b.id.client &&
   a.mutation === b.mutation &&
+  a.clientId === b.clientId &&
+  // a.sessionId === b.sessionId &&
   // TODO use schema equality here
   JSON.stringify(a.args) === JSON.stringify(b.args)

package/src/schema/db-schema/ast/sqlite.ts

@@ -0,0 +1,142 @@
+import { type Option, Schema } from '@livestore/utils/effect'
+
+import { hashCode } from '../hash.js'
+
+export namespace ColumnType {
+  export type ColumnType = Text | Null | Real | Integer | Blob
+
+  export type Text = { _tag: 'text' }
+
+  export type Null = { _tag: 'null' }
+
+  export type Real = { _tag: 'real' }
+
+  export type Integer = { _tag: 'integer' }
+
+  export type Blob = { _tag: 'blob' }
+}
+
+export type Column = {
+  _tag: 'column'
+  name: string
+  type: ColumnType.ColumnType
+  primaryKey: boolean
+  nullable: boolean
+  default: Option.Option<any>
+  schema: Schema.Schema<any>
+}
+
+export const column = (props: Omit<Column, '_tag'>): Column => ({ _tag: 'column', ...props })
+
+export type Index = {
+  _tag: 'index'
+  columns: ReadonlyArray<string>
+  name?: string
+  unique?: boolean
+  primaryKey?: boolean
+}
+
+export const index = (
+  columns: ReadonlyArray<string>,
+  name?: string,
+  unique?: boolean,
+  primaryKey?: boolean,
+): Index => ({
+  _tag: 'index',
+  columns,
+  name,
+  unique,
+  primaryKey,
+})
+
+export type ForeignKey = {
+  _tag: 'foreignKey'
+  references: {
+    table: string
+    columns: ReadonlyArray<string>
+  }
+  key: {
+    table: string
+    columns: ReadonlyArray<string>
+  }
+  columns: ReadonlyArray<string>
+}
+
+export type Table = {
+  _tag: 'table'
+  name: string
+  columns: ReadonlyArray<Column>
+  indexes: ReadonlyArray<Index>
+}
+
+export const table = (name: string, columns: ReadonlyArray<Column>, indexes: ReadonlyArray<Index>): Table => ({
+  _tag: 'table',
+  name,
+  columns,
+  indexes,
+})
+
+export type DbSchema = {
+  _tag: 'dbSchema'
+  tables: Table[]
+}
+
+export const dbSchema = (tables: Table[]): DbSchema => ({ _tag: 'dbSchema', tables })
+
+/**
+ * NOTE we're only including SQLite-relevant information in the hash (which excludes the schema mapping)
+ */
+export const hash = (obj: Table | Column | Index | ForeignKey | DbSchema): number =>
+  hashCode(JSON.stringify(trimInfoForHasing(obj)))
+
+const trimInfoForHasing = (obj: Table | Column | Index | ForeignKey | DbSchema): Record<string, any> => {
+  switch (obj._tag) {
+    case 'table': {
+      return {
+        _tag: 'table',
+        name: obj.name,
+        columns: obj.columns.map((column) => trimInfoForHasing(column)),
+        indexes: obj.indexes.map((index) => trimInfoForHasing(index)),
+      }
+    }
+    case 'column': {
+      return {
+        _tag: 'column',
+        name: obj.name,
+        type: obj.type._tag,
+        primaryKey: obj.primaryKey,
+        nullable: obj.nullable,
+        default: obj.default,
+      }
+    }
+    case 'index': {
+      return {
+        _tag: 'index',
+        columns: obj.columns,
+        name: obj.name,
+        unique: obj.unique,
+        primaryKey: obj.primaryKey,
+      }
+    }
+    case 'foreignKey': {
+      return {
+        _tag: 'foreignKey',
+        references: obj.references,
+        key: obj.key,
+        columns: obj.columns,
+      }
+    }
+    case 'dbSchema': {
+      return {
+        _tag: 'dbSchema',
+        tables: obj.tables.map(trimInfoForHasing),
+      }
+    }
+    default: {
+      throw new Error(`Unreachable: ${obj}`)
+    }
+  }
+}
+
+export const structSchemaForTable = (tableDef: Table) =>
+  Schema.Struct(Object.fromEntries(tableDef.columns.map((column) => [column.name, column.schema])))

package/src/schema/db-schema/ast/validate.ts

@@ -0,0 +1,13 @@
+import type { DbSchema } from './sqlite.js'
+
+// TODO
+export const validate = (_dbSchema: DbSchema) => {
+  /*
+	TODO:
+
+	- ensure no duplicate table names
+	- ensure no duplicate column names within a table
+	- ensure no duplicate index names globally
+	- ...
+	*/
+}

package/src/schema/db-schema/dsl/__snapshots__/field-defs.test.ts.snap

@@ -0,0 +1,206 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`FieldDefs > boolean 1`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 2`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 3`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": null,
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 4`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": "foo",
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 5`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": "foo",
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 6`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 7`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": null,
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 8`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": {
+      "name": "Bob",
+    },
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 9`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 10`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 11`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": null,
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 12`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": 2022-02-02T00:00:00.000Z,
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 13`] = `
+{
+  "columnType": "integer",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 14`] = `
+{
+  "columnType": "integer",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 15`] = `
+{
+  "columnType": "integer",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": false,
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;

package/src/schema/db-schema/dsl/field-defs.test.ts

@@ -0,0 +1,35 @@
+import { Schema } from '@livestore/utils/effect'
+import { describe, expect, test } from 'vitest'
+
+import * as F from './field-defs.js'
+
+describe.concurrent('FieldDefs', () => {
+  test('text', () => {
+    expect(F.text()).toMatchSnapshot()
+    expect(F.text({})).toMatchSnapshot()
+    expect(F.text({ default: null, nullable: true })).toMatchSnapshot()
+    expect(F.text({ schema: Schema.Literal('foo'), nullable: true, default: 'foo' })).toMatchSnapshot()
+    expect(F.text({ schema: Schema.Union(Schema.Literal('foo')), nullable: true, default: 'foo' })).toMatchSnapshot()
+  })
+
+  test('json', () => {
+    expect(F.json()).toMatchSnapshot()
+    expect(F.json({ default: null, nullable: true })).toMatchSnapshot()
+    expect(
+      F.json({ schema: Schema.Struct({ name: Schema.String }), default: { name: 'Bob' }, nullable: true }),
+    ).toMatchSnapshot()
+  })
+
+  test('datetime', () => {
+    expect(F.datetime()).toMatchSnapshot()
+    expect(F.datetime({})).toMatchSnapshot()
+    expect(F.datetime({ default: null, nullable: true })).toMatchSnapshot()
+    expect(F.datetime({ default: new Date('2022-02-02') })).toMatchSnapshot()
+  })
+
+  test('boolean', () => {
+    expect(F.boolean()).toMatchSnapshot()
+    expect(F.boolean({})).toMatchSnapshot()
+    expect(F.boolean({ default: false })).toMatchSnapshot()
+  })
+})