@livestore/common 0.3.2-dev.9 → 0.4.0-dev.0

package/src/schema/state/sqlite/column-annotations.test.ts

@@ -0,0 +1,212 @@
+import { Schema, SchemaAST } from '@livestore/utils/effect'
+import { describe, expect, test } from 'vitest'
+
+import { withColumnType, withPrimaryKey } from './column-annotations.ts'
+
+describe.concurrent('annotations', () => {
+  describe('withPrimaryKey', () => {
+    test('should add primary key annotation', () => {
+      const schema = Schema.String
+      const result = withPrimaryKey(schema)
+
+      expect(SchemaAST.annotations(result.ast, {})).toMatchInlineSnapshot(`
+        {
+          "_tag": "StringKeyword",
+          "annotations": {
+            "Symbol(effect/annotation/Description)": "a string",
+            "Symbol(effect/annotation/Title)": "string",
+            "Symbol(livestore/state/sqlite/annotations/primary-key)": true,
+          },
+        }
+      `)
+    })
+  })
+
+  describe('withColumnType', () => {
+    describe('compatible schema-column type combinations', () => {
+      test('Schema.String with text column type', () => {
+        expect(() => withColumnType(Schema.String, 'text')).not.toThrow()
+      })
+
+      test('Schema.Number with integer column type', () => {
+        expect(() => withColumnType(Schema.Number, 'integer')).not.toThrow()
+      })
+
+      test('Schema.Number with real column type', () => {
+        expect(() => withColumnType(Schema.Number, 'real')).not.toThrow()
+      })
+
+      test('Schema.Boolean with integer column type', () => {
+        expect(() => withColumnType(Schema.Boolean, 'integer')).not.toThrow()
+      })
+
+      test('Schema.Uint8ArrayFromSelf with blob column type', () => {
+        expect(() => withColumnType(Schema.Uint8ArrayFromSelf, 'blob')).not.toThrow()
+      })
+
+      test('Schema.Date with text column type', () => {
+        expect(() => withColumnType(Schema.Date, 'text')).not.toThrow()
+      })
+
+      test('String literal with text column type', () => {
+        expect(() => withColumnType(Schema.Literal('hello'), 'text')).not.toThrow()
+      })
+
+      test('Number literal with integer column type', () => {
+        expect(() => withColumnType(Schema.Literal(42), 'integer')).not.toThrow()
+      })
+
+      test('Number literal with real column type', () => {
+        expect(() => withColumnType(Schema.Literal(3.14), 'real')).not.toThrow()
+      })
+
+      test('Boolean literal with integer column type', () => {
+        expect(() => withColumnType(Schema.Literal(true), 'integer')).not.toThrow()
+      })
+
+      test('Union of same type with compatible column type', () => {
+        const unionSchema = Schema.Union(Schema.Literal('a'), Schema.Literal('b'))
+        expect(() => withColumnType(unionSchema, 'text')).not.toThrow()
+      })
+
+      test('Transformation schema with compatible base type', () => {
+        const transformSchema = Schema.transform(Schema.String, Schema.String, {
+          decode: (s) => s.toUpperCase(),
+          encode: (s) => s.toLowerCase(),
+        })
+        expect(() => withColumnType(transformSchema, 'text')).not.toThrow()
+      })
+    })
+
+    // TODO bring those tests back as we've implemented the column type validation
+    // describe('incompatible schema-column type combinations', () => {
+    //   test('Schema.String with integer column type should throw', () => {
+    //     expect(() => withColumnType(Schema.String, 'integer')).toThrow(
+    //       "Schema type 'string' is incompatible with column type 'integer'",
+    //     )
+    //   })
+
+    //   test('Schema.String with real column type should throw', () => {
+    //     expect(() => withColumnType(Schema.String, 'real')).toThrow(
+    //       "Schema type 'string' is incompatible with column type 'real'",
+    //     )
+    //   })
+
+    //   test('Schema.String with blob column type should throw', () => {
+    //     expect(() => withColumnType(Schema.String, 'blob')).toThrow(
+    //       "Schema type 'string' is incompatible with column type 'blob'",
+    //     )
+    //   })
+
+    //   test('Schema.Number with text column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Number, 'text')).toThrow(
+    //       "Schema type 'number' is incompatible with column type 'text'",
+    //     )
+    //   })
+
+    //   test('Schema.Number with blob column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Number, 'blob')).toThrow(
+    //       "Schema type 'number' is incompatible with column type 'blob'",
+    //     )
+    //   })
+
+    //   test('Schema.Boolean with text column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Boolean, 'text')).toThrow(
+    //       "Schema type 'boolean' is incompatible with column type 'text'",
+    //     )
+    //   })
+
+    //   test('Schema.Boolean with real column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Boolean, 'real')).toThrow(
+    //       "Schema type 'boolean' is incompatible with column type 'real'",
+    //     )
+    //   })
+
+    //   test('Schema.Boolean with blob column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Boolean, 'blob')).toThrow(
+    //       "Schema type 'boolean' is incompatible with column type 'blob'",
+    //     )
+    //   })
+
+    //   test('Schema.Uint8ArrayFromSelf with text column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Uint8ArrayFromSelf, 'text')).toThrow(
+    //       "Schema type 'uint8array' is incompatible with column type 'text'",
+    //     )
+    //   })
+
+    //   test('String literal with integer column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Literal('hello'), 'integer')).toThrow(
+    //       "Schema type 'string' is incompatible with column type 'integer'",
+    //     )
+    //   })
+
+    //   test('Number literal with text column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Literal(42), 'text')).toThrow(
+    //       "Schema type 'number' is incompatible with column type 'text'",
+    //     )
+    //   })
+
+    //   test('Schema.Date with integer column type should throw', () => {
+    //     expect(() => withColumnType(Schema.Date, 'integer')).toThrow(
+    //       "Schema type 'string' is incompatible with column type 'integer'",
+    //     )
+    //   })
+    // })
+
+    describe('complex schemas', () => {
+      test('should allow complex schemas that cannot be determined', () => {
+        const complexSchema = Schema.Struct({ name: Schema.String, age: Schema.Number })
+        expect(() => withColumnType(complexSchema, 'text')).not.toThrow()
+      })
+
+      test('should allow Schema.Any with any column type', () => {
+        expect(() => withColumnType(Schema.Any, 'text')).not.toThrow()
+        expect(() => withColumnType(Schema.Any, 'integer')).not.toThrow()
+        expect(() => withColumnType(Schema.Any, 'real')).not.toThrow()
+        expect(() => withColumnType(Schema.Any, 'blob')).not.toThrow()
+      })
+
+      test('should allow Schema.Unknown with any column type', () => {
+        expect(() => withColumnType(Schema.Unknown, 'text')).not.toThrow()
+        expect(() => withColumnType(Schema.Unknown, 'integer')).not.toThrow()
+        expect(() => withColumnType(Schema.Unknown, 'real')).not.toThrow()
+        expect(() => withColumnType(Schema.Unknown, 'blob')).not.toThrow()
+      })
+    })
+
+    describe('annotation behavior', () => {
+      test('should add column type annotation to schema', () => {
+        const schema = Schema.String
+        const result = withColumnType(schema, 'text')
+
+        expect(SchemaAST.annotations(result.ast, {})).toMatchInlineSnapshot(`
+          {
+            "_tag": "StringKeyword",
+            "annotations": {
+              "Symbol(effect/annotation/Description)": "a string",
+              "Symbol(effect/annotation/Title)": "string",
+              "Symbol(livestore/state/sqlite/annotations/column-type)": "text",
+            },
+          }
+        `)
+      })
+
+      test('should preserve existing annotations', () => {
+        const schema = withPrimaryKey(Schema.String)
+        const result = withColumnType(schema, 'text')
+
+        expect(SchemaAST.annotations(result.ast, {})).toMatchInlineSnapshot(`
+          {
+            "_tag": "StringKeyword",
+            "annotations": {
+              "Symbol(effect/annotation/Description)": "a string",
+              "Symbol(effect/annotation/Title)": "string",
+              "Symbol(livestore/state/sqlite/annotations/column-type)": "text",
+              "Symbol(livestore/state/sqlite/annotations/primary-key)": true,
+            },
+          }
+        `)
+      })
+    })
+  })
+})

package/src/schema/state/sqlite/column-annotations.ts

@@ -0,0 +1,77 @@
+import type { Schema } from '@livestore/utils/effect'
+import { dual } from '@livestore/utils/effect'
+import type { SqliteDsl } from './db-schema/mod.ts'
+
+export const PrimaryKeyId = Symbol.for('livestore/state/sqlite/annotations/primary-key')
+
+export const ColumnType = Symbol.for('livestore/state/sqlite/annotations/column-type')
+
+export const Default = Symbol.for('livestore/state/sqlite/annotations/default')
+
+export const AutoIncrement = Symbol.for('livestore/state/sqlite/annotations/auto-increment')
+
+export const Unique = Symbol.for('livestore/state/sqlite/annotations/unique')
+
+// export const Check = Symbol.for('livestore/state/sqlite/annotations/check')
+
+/*
+Here are the knobs you can turn per-column when you CREATE TABLE (or ALTER TABLE … ADD COLUMN) in SQLite:
+•	Declared type / affinity – INTEGER, TEXT, REAL, BLOB, NUMERIC, etc.  
+•	NULL vs NOT NULL – disallow NULL on inserts/updates.  
+•	PRIMARY KEY – makes the column the rowid (and, if the type is INTEGER, it enables rowid-based auto- numbering). Add the optional AUTOINCREMENT keyword if you need monotonic, never-reused ids.  
+•	UNIQUE – enforces per-column uniqueness.  
+•	DEFAULT <expr> – literal, function (e.g. CURRENT_TIMESTAMP), or parenthesised expression; since 3.46 you can even default to large hex blobs.  
+•	CHECK (<expr>) – arbitrary boolean expression evaluated on write.  
+•	COLLATE <name> – per-column collation sequence for text comparison.  
+•	REFERENCES tbl(col) [ON UPDATE/DELETE …] – column-local foreign key with its own cascade / restrict / set-null rules.  
+•	GENERATED ALWAYS AS (<expr>) [VIRTUAL | STORED] – computed columns (since 3.31).  
+•	CONSTRAINT name … – optional label in front of any of the above so you can refer to it in error messages or when dropping/recreating schemas.  
+*/
+
+/**
+ * Adds a primary key annotation to a schema.
+ */
+export const withPrimaryKey = <T extends Schema.Schema.All>(schema: T) =>
+  schema.annotations({ [PrimaryKeyId]: true }) as T
+
+/**
+ * Adds a column type annotation to a schema.
+ */
+export const withColumnType: {
+  (type: SqliteDsl.FieldColumnType): <T extends Schema.Schema.All>(schema: T) => T
+  // TODO make type safe
+  <T extends Schema.Schema.All>(schema: T, type: SqliteDsl.FieldColumnType): T
+} = dual(2, <T extends Schema.Schema.All>(schema: T, type: SqliteDsl.FieldColumnType) => {
+  validateSchemaColumnTypeCompatibility(schema, type)
+  return schema.annotations({ [ColumnType]: type }) as T
+})
+
+/**
+ * Adds an auto-increment annotation to a schema.
+ */
+export const withAutoIncrement = <T extends Schema.Schema.All>(schema: T) =>
+  schema.annotations({ [AutoIncrement]: true }) as T
+
+/**
+ * Adds a unique constraint annotation to a schema.
+ */
+export const withUnique = <T extends Schema.Schema.All>(schema: T) => schema.annotations({ [Unique]: true }) as T
+
+/**
+ * Adds a default value annotation to a schema.
+ */
+export const withDefault: {
+  // TODO make type safe
+  <T extends Schema.Schema.All>(schema: T, value: unknown): T
+  (value: unknown): <T extends Schema.Schema.All>(schema: T) => T
+} = dual(2, <T extends Schema.Schema.All>(schema: T, value: unknown) => schema.annotations({ [Default]: value }) as T)
+
+/**
+ * Validates that a schema is compatible with the specified SQLite column type
+ */
+const validateSchemaColumnTypeCompatibility = (
+  _schema: Schema.Schema.All,
+  _columnType: SqliteDsl.FieldColumnType,
+): void => {
+  // TODO actually implement this
+}

package/src/schema/state/sqlite/column-spec.test.ts

@@ -0,0 +1,223 @@
+import { Option, Schema } from '@livestore/utils/effect'
+import { describe, expect, it } from 'vitest'
+import { makeColumnSpec } from './column-spec.ts'
+import { SqliteAst } from './db-schema/mod.ts'
+
+const createColumn = (
+  name: string,
+  type: 'text' | 'integer' | 'real' | 'blob',
+  options: {
+    nullable?: boolean
+    primaryKey?: boolean
+    autoIncrement?: boolean
+    defaultValue?: unknown
+    defaultSql?: string
+  } = {},
+): SqliteAst.Column => {
+  let defaultOption: Option.Option<unknown> = Option.none()
+  if (options.defaultSql !== undefined) {
+    defaultOption = Option.some({ sql: options.defaultSql })
+  } else if (options.defaultValue !== undefined) {
+    defaultOption = Option.some(options.defaultValue)
+  }
+
+  const schema = (() => {
+    switch (type) {
+      case 'text':
+        return Schema.String
+      case 'integer':
+        return options.defaultValue === true || options.defaultValue === false ? Schema.Boolean : Schema.Number
+      case 'real':
+        return Schema.Number
+      case 'blob':
+        return Schema.Uint8ArrayFromBase64
+      default:
+        return Schema.Unknown
+    }
+  })()
+
+  return SqliteAst.column({
+    name,
+    type: { _tag: type },
+    nullable: options.nullable ?? true,
+    primaryKey: options.primaryKey ?? false,
+    autoIncrement: options.autoIncrement ?? false,
+    default: defaultOption,
+    schema,
+  })
+}
+
+describe('makeColumnSpec', () => {
+  it('should quote column names properly for reserved keywords', () => {
+    const table = SqliteAst.table(
+      'blocks',
+      [createColumn('order', 'integer', { nullable: false }), createColumn('group', 'text')],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(`"'order' integer not null  , 'group' text   "`)
+    expect(result).toContain("'order'")
+    expect(result).toContain("'group'")
+  })
+
+  it('should handle basic columns with primary keys', () => {
+    const table = SqliteAst.table(
+      'users',
+      [createColumn('id', 'text', { nullable: false, primaryKey: true }), createColumn('name', 'text')],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(`"'id' text not null  , 'name' text   , PRIMARY KEY ('id')"`)
+    expect(result).toContain("PRIMARY KEY ('id')")
+  })
+
+  it('should handle multi-column primary keys', () => {
+    const table = SqliteAst.table(
+      'composite',
+      [
+        createColumn('tenant_id', 'text', { nullable: false, primaryKey: true }),
+        createColumn('user_id', 'text', { nullable: false, primaryKey: true }),
+      ],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(
+      `"'tenant_id' text not null  , 'user_id' text not null  , PRIMARY KEY ('tenant_id', 'user_id')"`,
+    )
+    expect(result).toContain("PRIMARY KEY ('tenant_id', 'user_id')")
+  })
+
+  it('should handle auto-increment columns', () => {
+    const table = SqliteAst.table(
+      'posts',
+      [
+        createColumn('id', 'integer', { nullable: false, primaryKey: true, autoIncrement: true }),
+        createColumn('title', 'text'),
+      ],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(`"'id' integer not null autoincrement , 'title' text   , PRIMARY KEY ('id')"`)
+    expect(result).toContain('autoincrement')
+    expect(result).toContain("PRIMARY KEY ('id')")
+  })
+
+  it('should handle columns with default values', () => {
+    const table = SqliteAst.table(
+      'products',
+      [
+        createColumn('id', 'integer', { nullable: false, primaryKey: true }),
+        createColumn('name', 'text', { nullable: false }),
+        createColumn('price', 'real', { defaultValue: 0 }),
+        createColumn('active', 'integer', { defaultValue: true }),
+        createColumn('description', 'text', { defaultValue: 'No description' }),
+      ],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(
+      `"'id' integer not null  , 'name' text not null  , 'price' real   default 0, 'active' integer   default true, 'description' text   default 'No description', PRIMARY KEY ('id')"`,
+    )
+    expect(result).toContain('default 0')
+    expect(result).toContain('default true')
+    expect(result).toContain("default 'No description'")
+  })
+
+  it('should handle columns with SQL default values', () => {
+    const table = SqliteAst.table(
+      'logs',
+      [
+        createColumn('id', 'integer', { nullable: false, primaryKey: true }),
+        createColumn('created_at', 'text', { defaultSql: 'CURRENT_TIMESTAMP' }),
+        createColumn('random_value', 'real', { defaultSql: 'RANDOM()' }),
+      ],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(
+      `"'id' integer not null  , 'created_at' text   default CURRENT_TIMESTAMP, 'random_value' real   default RANDOM(), PRIMARY KEY ('id')"`,
+    )
+    expect(result).toContain('default CURRENT_TIMESTAMP')
+    expect(result).toContain('default RANDOM()')
+  })
+
+  it('should handle null default values', () => {
+    const table = SqliteAst.table(
+      'nullable_defaults',
+      [
+        createColumn('id', 'integer', { nullable: false, primaryKey: true }),
+        createColumn('optional_text', 'text', { defaultValue: null }),
+      ],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(
+      `"'id' integer not null  , 'optional_text' text   default null, PRIMARY KEY ('id')"`,
+    )
+    expect(result).toContain('default null')
+  })
+
+  it('should handle all column features combined', () => {
+    const table = SqliteAst.table(
+      'complex_table',
+      [
+        createColumn('id', 'integer', {
+          nullable: false,
+          primaryKey: true,
+          autoIncrement: true,
+        }),
+        createColumn('name', 'text', {
+          nullable: false,
+          defaultValue: 'Unnamed',
+        }),
+        createColumn('created_at', 'text', {
+          nullable: false,
+          defaultSql: 'CURRENT_TIMESTAMP',
+        }),
+        createColumn('status', 'text', {
+          defaultValue: 'pending',
+        }),
+      ],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(
+      `"'id' integer not null autoincrement , 'name' text not null  default 'Unnamed', 'created_at' text not null  default CURRENT_TIMESTAMP, 'status' text   default 'pending', PRIMARY KEY ('id')"`,
+    )
+  })
+
+  it('should handle tables with indexes', () => {
+    const table = SqliteAst.table(
+      'users_with_indexes',
+      [
+        createColumn('id', 'integer', { nullable: false, primaryKey: true, autoIncrement: true }),
+        createColumn('email', 'text', { nullable: false }),
+        createColumn('username', 'text', { nullable: false }),
+        createColumn('created_at', 'text', { defaultSql: 'CURRENT_TIMESTAMP' }),
+      ],
+      [
+        SqliteAst.index(['email'], 'idx_users_email', true),
+        SqliteAst.index(['username'], 'idx_users_username'),
+        SqliteAst.index(['created_at'], 'idx_users_created_at'),
+      ],
+    )
+
+    const result = makeColumnSpec(table)
+    // The makeColumnSpec function only generates column specifications, not indexes
+    expect(result).toMatchInlineSnapshot(
+      `"'id' integer not null autoincrement , 'email' text not null  , 'username' text not null  , 'created_at' text   default CURRENT_TIMESTAMP, PRIMARY KEY ('id')"`,
+    )
+    // Verify the table has the indexes (even though they're not in the column spec)
+    expect(table.indexes).toHaveLength(3)
+    expect(table.indexes[0]!.unique).toBe(true)
+    expect(table.indexes[1]!.unique).toBeUndefined()
+  })
+})

package/src/schema/state/sqlite/column-spec.ts

@@ -0,0 +1,42 @@
+import { Schema } from '@livestore/utils/effect'
+import { type SqliteAst, SqliteDsl } from './db-schema/mod.ts'
+
+/**
+ * Returns a SQLite column specification string for a table's column definitions.
+ *
+ * Example:
+ * ```
+ * 'id' integer not null autoincrement , 'email' text not null  , 'username' text not null  , 'created_at' text   default CURRENT_TIMESTAMP, PRIMARY KEY ('id')
+ * ```
+ */
+export const makeColumnSpec = (tableAst: SqliteAst.Table) => {
+  const primaryKeys = tableAst.columns.filter((_) => _.primaryKey).map((_) => `'${_.name}'`)
+  const columnDefStrs = tableAst.columns.map(toSqliteColumnSpec)
+
+  if (primaryKeys.length > 0) {
+    columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
+  }
+
+  return columnDefStrs.join(', ')
+}
+
+/** NOTE primary keys are applied on a table level not on a column level to account for multi-column primary keys */
+const toSqliteColumnSpec = (column: SqliteAst.Column) => {
+  const columnTypeStr = column.type._tag
+  const nullableStr = column.nullable === false ? 'not null' : ''
+  const autoIncrementStr = column.autoIncrement ? 'autoincrement' : ''
+  const defaultValueStr = (() => {
+    if (column.default._tag === 'None') return ''
+
+    if (column.default.value === null) return 'default null'
+    if (SqliteDsl.isSqlDefaultValue(column.default.value)) return `default ${column.default.value.sql}`
+
+    const encodeValue = Schema.encodeSync(column.schema)
+    const encodedDefaultValue = encodeValue(column.default.value)
+
+    if (columnTypeStr === 'text') return `default '${encodedDefaultValue}'`
+    return `default ${encodedDefaultValue}`
+  })()
+
+  return `'${column.name}' ${columnTypeStr} ${nullableStr} ${autoIncrementStr} ${defaultValueStr}`
+}

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

@@ -22,6 +22,7 @@ export type Column = {
   type: ColumnType.ColumnType
   primaryKey: boolean
   nullable: boolean
+  autoIncrement: boolean
   default: Option.Option<any>
   schema: Schema.Schema<any>
 }
@@ -106,6 +107,7 @@ const trimInfoForHasing = (obj: Table | Column | Index | ForeignKey | DbSchema):
         type: obj.type._tag,
         primaryKey: obj.primaryKey,
         nullable: obj.nullable,
+        autoIncrement: obj.autoIncrement,
         default: obj.default,
       }
     }

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

@@ -2,6 +2,7 @@
 
 exports[`FieldDefs > boolean 1`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -15,6 +16,7 @@ exports[`FieldDefs > boolean 1`] = `
 
 exports[`FieldDefs > boolean 2`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -28,6 +30,7 @@ exports[`FieldDefs > boolean 2`] = `
 
 exports[`FieldDefs > boolean 3`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -42,6 +45,7 @@ exports[`FieldDefs > boolean 3`] = `
 
 exports[`FieldDefs > boolean 4`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -56,6 +60,7 @@ exports[`FieldDefs > boolean 4`] = `
 
 exports[`FieldDefs > boolean 5`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -70,6 +75,7 @@ exports[`FieldDefs > boolean 5`] = `
 
 exports[`FieldDefs > boolean 6`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -83,6 +89,7 @@ exports[`FieldDefs > boolean 6`] = `
 
 exports[`FieldDefs > boolean 7`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -97,6 +104,7 @@ exports[`FieldDefs > boolean 7`] = `
 
 exports[`FieldDefs > boolean 8`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -113,6 +121,7 @@ exports[`FieldDefs > boolean 8`] = `
 
 exports[`FieldDefs > boolean 9`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -126,6 +135,7 @@ exports[`FieldDefs > boolean 9`] = `
 
 exports[`FieldDefs > boolean 10`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -139,6 +149,7 @@ exports[`FieldDefs > boolean 10`] = `
 
 exports[`FieldDefs > boolean 11`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -153,6 +164,7 @@ exports[`FieldDefs > boolean 11`] = `
 
 exports[`FieldDefs > boolean 12`] = `
 {
+  "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
@@ -167,6 +179,7 @@ exports[`FieldDefs > boolean 12`] = `
 
 exports[`FieldDefs > boolean 13`] = `
 {
+  "autoIncrement": false,
   "columnType": "integer",
   "default": {
     "_id": "Option",
@@ -180,6 +193,7 @@ exports[`FieldDefs > boolean 13`] = `
 
 exports[`FieldDefs > boolean 14`] = `
 {
+  "autoIncrement": false,
   "columnType": "integer",
   "default": {
     "_id": "Option",
@@ -193,6 +207,7 @@ exports[`FieldDefs > boolean 14`] = `
 
 exports[`FieldDefs > boolean 15`] = `
 {
+  "autoIncrement": false,
   "columnType": "integer",
   "default": {
     "_id": "Option",