@livestore/common 0.3.0-dev.3 → 0.3.0-dev.31

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()
+  })
+})

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

@@ -0,0 +1,242 @@
+import { casesHandled } from '@livestore/utils'
+import { Option, Schema } from '@livestore/utils/effect'
+
+export type ColumnDefinition<TEncoded, TDecoded> = {
+  readonly columnType: FieldColumnType
+  readonly schema: Schema.Schema<TDecoded, TEncoded>
+  readonly default: Option.Option<TEncoded>
+  /** @default false */
+  readonly nullable: boolean
+  /** @default false */
+  readonly primaryKey: boolean
+}
+
+export const isColumnDefinition = (value: unknown): value is ColumnDefinition<any, any> => {
+  const validColumnTypes = ['text', 'integer', 'real', 'blob'] as const
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'columnType' in value &&
+    validColumnTypes.includes(value['columnType'] as any)
+  )
+}
+
+export type ColumnDefinitionInput = {
+  readonly schema?: Schema.Schema<unknown>
+  readonly default?: unknown | NoDefault
+  readonly nullable?: boolean
+  readonly primaryKey?: boolean
+}
+
+export const NoDefault = Symbol.for('NoDefault')
+export type NoDefault = typeof NoDefault
+
+export type SqlDefaultValue = {
+  readonly sql: string
+}
+
+export const isSqlDefaultValue = (value: unknown): value is SqlDefaultValue => {
+  return typeof value === 'object' && value !== null && 'sql' in value && typeof value['sql'] === 'string'
+}
+
+export type ColDefFn<TColumnType extends FieldColumnType> = {
+  (): {
+    columnType: TColumnType
+    schema: Schema.Schema<DefaultEncodedForColumnType<TColumnType>>
+    default: Option.None<never>
+    nullable: false
+    primaryKey: false
+  }
+  <
+    TEncoded extends DefaultEncodedForColumnType<TColumnType>,
+    TDecoded = DefaultEncodedForColumnType<TColumnType>,
+    const TNullable extends boolean = false,
+    const TDefault extends TDecoded | SqlDefaultValue | NoDefault | (TNullable extends true ? null : never) = NoDefault,
+    const TPrimaryKey extends boolean = false,
+  >(args: {
+    schema?: Schema.Schema<TDecoded, TEncoded>
+    default?: TDefault
+    nullable?: TNullable
+    primaryKey?: TPrimaryKey
+  }): {
+    columnType: TColumnType
+    schema: TNullable extends true
+      ? Schema.Schema<NoInfer<TDecoded> | null, NoInfer<TEncoded> | null>
+      : Schema.Schema<NoInfer<TDecoded>, NoInfer<TEncoded>>
+    default: TDefault extends NoDefault ? Option.None<never> : Option.Some<NoInfer<TDefault>>
+    nullable: NoInfer<TNullable>
+    primaryKey: NoInfer<TPrimaryKey>
+  }
+}
+
+const makeColDef =
+  <TColumnType extends FieldColumnType>(columnType: TColumnType): ColDefFn<TColumnType> =>
+  (def?: ColumnDefinitionInput) => {
+    const nullable = def?.nullable ?? false
+    const schemaWithoutNull: Schema.Schema<any> = def?.schema ?? defaultSchemaForColumnType(columnType)
+    const schema = nullable === true ? Schema.NullOr(schemaWithoutNull) : schemaWithoutNull
+    const default_ = def?.default === undefined || def.default === NoDefault ? Option.none() : Option.some(def.default)
+
+    return {
+      columnType,
+      schema,
+      default: default_,
+      nullable,
+      primaryKey: def?.primaryKey ?? false,
+    } as any
+  }
+
+export const column = <TColumnType extends FieldColumnType>(columnType: TColumnType): ColDefFn<TColumnType> =>
+  makeColDef(columnType)
+
+/// Column definitions
+
+export const text: ColDefFn<'text'> = makeColDef('text')
+export const integer: ColDefFn<'integer'> = makeColDef('integer')
+export const real: ColDefFn<'real'> = makeColDef('real')
+export const blob: ColDefFn<'blob'> = makeColDef('blob')
+
+/**
+ * `NoInfer` is needed for some generics to work properly in certain cases.
+ * See full explanation here: https://gist.github.com/schickling/a15e96819826530492b41a10d79d3c04?permalink_comment_id=4805120#gistcomment-4805120
+ *
+ * Big thanks to @andarist for their help with this!
+ */
+type NoInfer<T> = [T][T extends any ? 0 : never]
+
+export type SpecializedColDefFn<
+  TColumnType extends FieldColumnType,
+  TAllowsCustomSchema extends boolean,
+  TBaseDecoded,
+> = {
+  (): {
+    columnType: TColumnType
+    schema: Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+    default: Option.None<never>
+    nullable: false
+    primaryKey: false
+  }
+  <
+    TDecoded = TBaseDecoded,
+    const TNullable extends boolean = false,
+    const TDefault extends TDecoded | NoDefault | (TNullable extends true ? null : never) = NoDefault,
+    const TPrimaryKey extends boolean = false,
+  >(
+    args: TAllowsCustomSchema extends true
+      ? {
+          schema?: Schema.Schema<TDecoded, any>
+          default?: TDefault
+          nullable?: TNullable
+          primaryKey?: TPrimaryKey
+        }
+      : {
+          default?: TDefault
+          nullable?: TNullable
+          primaryKey?: TPrimaryKey
+        },
+  ): {
+    columnType: TColumnType
+    schema: TNullable extends true
+      ? Schema.Schema<NoInfer<TDecoded> | null, DefaultEncodedForColumnType<TColumnType> | null>
+      : Schema.Schema<NoInfer<TDecoded>, DefaultEncodedForColumnType<TColumnType>>
+    default: TDefault extends NoDefault ? Option.None<never> : Option.Some<TDefault>
+    nullable: NoInfer<TNullable>
+    primaryKey: NoInfer<TPrimaryKey>
+  }
+}
+
+type MakeSpecializedColDefFn = {
+  <TColumnType extends FieldColumnType, TBaseDecoded>(
+    columnType: TColumnType,
+    opts: {
+      _tag: 'baseSchema'
+      baseSchema: Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+    },
+  ): SpecializedColDefFn<TColumnType, false, TBaseDecoded>
+  <TColumnType extends FieldColumnType, TBaseDecoded>(
+    columnType: TColumnType,
+    opts: {
+      _tag: 'baseSchemaFn'
+      baseSchemaFn: <TDecoded>(
+        customSchema: Schema.Schema<TDecoded, TBaseDecoded> | undefined,
+      ) => Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+    },
+  ): SpecializedColDefFn<TColumnType, true, TBaseDecoded>
+}
+
+const makeSpecializedColDef: MakeSpecializedColDefFn = (columnType, opts) => (def?: ColumnDefinitionInput) => {
+  const nullable = def?.nullable ?? false
+  const schemaWithoutNull = opts._tag === 'baseSchemaFn' ? opts.baseSchemaFn(def?.schema as any) : opts.baseSchema
+  const schema = nullable === true ? Schema.NullOr(schemaWithoutNull) : schemaWithoutNull
+  const default_ = def?.default === undefined || def.default === NoDefault ? Option.none() : Option.some(def.default)
+
+  return {
+    columnType,
+    schema,
+    default: default_,
+    nullable,
+    primaryKey: def?.primaryKey ?? false,
+  } as any
+}
+
+export const json: SpecializedColDefFn<'text', true, unknown> = makeSpecializedColDef('text', {
+  _tag: 'baseSchemaFn',
+  baseSchemaFn: (customSchema) => Schema.parseJson(customSchema ?? Schema.Any),
+})
+
+export const datetime: SpecializedColDefFn<'text', false, Date> = makeSpecializedColDef('text', {
+  _tag: 'baseSchema',
+  baseSchema: Schema.Date,
+})
+
+export const datetimeInteger: SpecializedColDefFn<'integer', false, Date> = makeSpecializedColDef('integer', {
+  _tag: 'baseSchema',
+  baseSchema: Schema.transform(Schema.Number, Schema.DateFromSelf, {
+    decode: (ms) => new Date(ms),
+    encode: (date) => date.getTime(),
+  }),
+})
+
+export const boolean: SpecializedColDefFn<'integer', false, boolean> = makeSpecializedColDef('integer', {
+  _tag: 'baseSchema',
+  baseSchema: Schema.transform(Schema.Number, Schema.Boolean, {
+    decode: (_) => _ === 1,
+    encode: (_) => (_ ? 1 : 0),
+  }),
+})
+
+export type FieldColumnType = 'text' | 'integer' | 'real' | 'blob'
+
+export type DefaultEncodedForColumnType<TColumnType extends FieldColumnType> = TColumnType extends 'text'
+  ? string
+  : TColumnType extends 'integer'
+    ? number
+    : TColumnType extends 'real'
+      ? number
+      : TColumnType extends 'blob'
+        ? Uint8Array
+        : never
+
+export const defaultSchemaForColumnType = <TColumnType extends FieldColumnType>(
+  columnType: TColumnType,
+): Schema.Schema<DefaultEncodedForColumnType<TColumnType>> => {
+  type T = DefaultEncodedForColumnType<TColumnType>
+
+  switch (columnType) {
+    case 'text': {
+      return Schema.String as any as Schema.Schema<T>
+    }
+    case 'integer': {
+      return Schema.Number as any as Schema.Schema<T>
+    }
+    case 'real': {
+      return Schema.Number as any as Schema.Schema<T>
+    }
+    case 'blob': {
+      return Schema.Uint8ArrayFromSelf as any as Schema.Schema<T>
+    }
+    default: {
+      return casesHandled(columnType)
+    }
+  }
+}