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

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

@@ -0,0 +1,290 @@
+import { shouldNeverHappen, type Writeable } from '@livestore/utils'
+import { Option, Schema, SchemaAST } from '@livestore/utils/effect'
+
+import { AutoIncrement, ColumnType, Default, PrimaryKeyId, Unique } from './column-annotations.ts'
+import { SqliteDsl } from './db-schema/mod.ts'
+
+/**
+ * Maps a schema to a SQLite column definition, respecting column annotations.
+ */
+export const getColumnDefForSchema = (
+  schema: Schema.Schema.AnyNoContext,
+  propertySignature?: SchemaAST.PropertySignature,
+): SqliteDsl.ColumnDefinition.Any => {
+  const ast = schema.ast
+
+  // 1. Extract annotations
+  const getAnnotation = <T>(annotationId: symbol): Option.Option<T> =>
+    propertySignature
+      ? hasPropertyAnnotation<T>(propertySignature, annotationId)
+      : SchemaAST.getAnnotation<T>(annotationId)(ast)
+
+  const annotations = {
+    primaryKey: getAnnotation<boolean>(PrimaryKeyId).pipe(Option.getOrElse(() => false)),
+    autoIncrement: getAnnotation<boolean>(AutoIncrement).pipe(Option.getOrElse(() => false)),
+    defaultValue: getAnnotation<unknown>(Default),
+    columnType: SchemaAST.getAnnotation<SqliteDsl.FieldColumnType>(ColumnType)(ast),
+  }
+
+  // 2. Resolve the core type and nullable info
+  const typeInfo = resolveType(ast)
+
+  // 3. Create column definition based on resolved type
+  let columnDef: SqliteDsl.ColumnDefinition.Any
+
+  // Custom column type overrides everything
+  if (Option.isSome(annotations.columnType)) {
+    columnDef = createColumnFromType(annotations.columnType.value, typeInfo.coreType)
+  }
+  // Lossy case: both null and undefined need JSON
+  else if (typeInfo.hasNull && typeInfo.hasUndefined) {
+    columnDef = {
+      ...SqliteDsl.text(),
+      nullable: true,
+      schema: Schema.parseJson(schema),
+    }
+  }
+  // Regular nullable/optional case
+  else if (typeInfo.hasNull || typeInfo.hasUndefined) {
+    const baseColumnDef = createColumnFromAST(typeInfo.coreType, Schema.make(typeInfo.coreType))
+    const isComplexOptional = typeInfo.hasUndefined && !isPrimitiveAST(typeInfo.coreType)
+
+    columnDef = {
+      ...baseColumnDef,
+      nullable: true,
+      schema: isComplexOptional ? Schema.parseJson(schema) : schema,
+    }
+  }
+  // Non-nullable type
+  else {
+    columnDef = createColumnFromAST(ast, schema)
+  }
+
+  // 4. Apply annotations
+  const result = { ...columnDef }
+  if (annotations.primaryKey) result.primaryKey = true
+  if (annotations.autoIncrement) result.autoIncrement = true
+  if (Option.isSome(annotations.defaultValue)) {
+    result.default = Option.some(annotations.defaultValue.value)
+  }
+
+  return result
+}
+
+/**
+ * Checks if a property signature has a specific annotation, checking both
+ * the property signature itself and its type AST.
+ */
+const hasPropertyAnnotation = <T>(
+  propertySignature: SchemaAST.PropertySignature,
+  annotationId: symbol,
+): Option.Option<T> => {
+  // When using Schema.optional(Schema.String).pipe(withPrimaryKey) in a struct,
+  // the annotation ends up on a PropertySignatureDeclaration, not the Union type
+  // Check if this is a PropertySignatureDeclaration with annotations
+  if ('annotations' in propertySignature && propertySignature.annotations) {
+    const annotation = SchemaAST.getAnnotation<T>(annotationId)(propertySignature as any)
+    if (Option.isSome(annotation)) {
+      return annotation
+    }
+  }
+
+  // Otherwise check the type AST
+  return SchemaAST.getAnnotation<T>(annotationId)(propertySignature.type)
+}
+
+/**
+ * Maps schema property signatures to SQLite column definitions.
+ * Returns both columns and unique column names for index creation.
+ */
+export const schemaFieldsToColumns = (
+  propertySignatures: ReadonlyArray<SchemaAST.PropertySignature>,
+): { columns: SqliteDsl.Columns; uniqueColumns: string[] } => {
+  const columns: SqliteDsl.Columns = {}
+  const uniqueColumns: string[] = []
+
+  for (const prop of propertySignatures) {
+    if (typeof prop.name === 'string') {
+      // Create a schema from the AST
+      const fieldSchema = Schema.make(prop.type)
+      // Check if property has primary key annotation
+      const hasPrimaryKey = hasPropertyAnnotation<boolean>(prop, PrimaryKeyId).pipe(Option.getOrElse(() => false))
+      // Check if property has unique annotation
+      const hasUnique = hasPropertyAnnotation<boolean>(prop, Unique).pipe(Option.getOrElse(() => false))
+
+      columns[prop.name] = schemaFieldToColumn(fieldSchema, prop, hasPrimaryKey)
+
+      if (hasUnique) {
+        uniqueColumns.push(prop.name)
+      }
+    }
+  }
+
+  return { columns, uniqueColumns }
+}
+
+/**
+ * Converts a schema field and its property signature to a SQLite column definition.
+ */
+const schemaFieldToColumn = (
+  fieldSchema: Schema.Schema.AnyNoContext,
+  propertySignature: SchemaAST.PropertySignature,
+  forceHasPrimaryKey?: boolean,
+): SqliteDsl.ColumnDefinition.Any => {
+  // Determine column type based on schema type
+  const columnDef = getColumnDefForSchema(fieldSchema, propertySignature)
+
+  // Create a new object with appropriate properties
+  const result: Writeable<SqliteDsl.ColumnDefinition.Any> = {
+    columnType: columnDef.columnType,
+    schema: columnDef.schema,
+    default: columnDef.default,
+    nullable: columnDef.nullable,
+    primaryKey: columnDef.primaryKey,
+    autoIncrement: columnDef.autoIncrement,
+  }
+
+  // Set primaryKey property explicitly
+  if (forceHasPrimaryKey || columnDef.primaryKey) {
+    result.primaryKey = true
+  } else {
+    result.primaryKey = false
+  }
+
+  // Check for invalid primary key + nullable combination
+  if (result.primaryKey && (propertySignature.isOptional || columnDef.nullable)) {
+    return shouldNeverHappen(
+      `Primary key columns cannot be nullable. Found nullable primary key for column. ` +
+        `Either remove the primary key annotation or use a non-nullable schema.`,
+    )
+  }
+
+  // Set nullable property explicitly
+  if (propertySignature.isOptional) {
+    result.nullable = true
+  } else if (columnDef.nullable) {
+    result.nullable = true
+  } else {
+    result.nullable = false
+  }
+
+  // Only add autoIncrement if it's true
+  if (columnDef.autoIncrement) {
+    result.autoIncrement = true
+  }
+
+  return result as SqliteDsl.ColumnDefinition.Any
+}
+
+/**
+ * Resolves type information from an AST, unwrapping unions and tracking nullability.
+ */
+const resolveType = (
+  ast: SchemaAST.AST,
+): {
+  coreType: SchemaAST.AST
+  hasNull: boolean
+  hasUndefined: boolean
+} => {
+  if (!SchemaAST.isUnion(ast)) {
+    return { coreType: ast, hasNull: false, hasUndefined: false }
+  }
+
+  let hasNull = false
+  let hasUndefined = false
+  let coreType: SchemaAST.AST | undefined
+
+  const visit = (type: SchemaAST.AST): void => {
+    if (SchemaAST.isUndefinedKeyword(type)) {
+      hasUndefined = true
+    } else if (SchemaAST.isLiteral(type) && type.literal === null) {
+      hasNull = true
+    } else if (SchemaAST.isUnion(type)) {
+      type.types.forEach(visit)
+    } else if (!coreType) {
+      coreType = type
+    }
+  }
+
+  ast.types.forEach(visit)
+  return { coreType: coreType || ast, hasNull, hasUndefined }
+}
+
+/**
+ * Creates a column definition from an AST node.
+ */
+const createColumnFromAST = (
+  ast: SchemaAST.AST,
+  schema: Schema.Schema.AnyNoContext,
+): SqliteDsl.ColumnDefinition.Any => {
+  // Follow refinements and transformations to their core type
+  if (SchemaAST.isRefinement(ast)) {
+    // Special case for Schema.Int
+    const identifier = SchemaAST.getIdentifierAnnotation(ast).pipe(Option.getOrElse(() => ''))
+    if (identifier === 'Int') return SqliteDsl.integer()
+    return createColumnFromAST(ast.from, Schema.make(ast.from))
+  }
+
+  if (SchemaAST.isTransformation(ast)) {
+    return createColumnFromAST(ast.to, Schema.make(ast.to))
+  }
+
+  // Primitive types
+  if (SchemaAST.isStringKeyword(ast)) return SqliteDsl.text()
+  if (SchemaAST.isNumberKeyword(ast)) return SqliteDsl.real()
+  if (SchemaAST.isBooleanKeyword(ast)) return SqliteDsl.boolean()
+
+  // Literals
+  if (SchemaAST.isLiteral(ast)) {
+    const value = ast.literal
+    if (typeof value === 'string') return SqliteDsl.text()
+    if (typeof value === 'number') return SqliteDsl.real()
+    if (typeof value === 'boolean') return SqliteDsl.boolean()
+  }
+
+  // Everything else is complex
+  return SqliteDsl.json({ schema })
+}
+
+/**
+ * Creates a column from a specific column type string.
+ */
+const createColumnFromType = (columnType: string, ast: SchemaAST.AST): SqliteDsl.ColumnDefinition.Any => {
+  switch (columnType) {
+    case 'text':
+      return SqliteDsl.text()
+    case 'integer':
+      // Preserve boolean transformation
+      return SchemaAST.isBooleanKeyword(ast) ? SqliteDsl.boolean() : SqliteDsl.integer()
+    case 'real':
+      return SqliteDsl.real()
+    case 'blob':
+      return SqliteDsl.blob()
+    default:
+      return shouldNeverHappen(`Unsupported column type: ${columnType}`)
+  }
+}
+
+/**
+ * Checks if an AST represents a primitive (non-complex) type.
+ */
+const isPrimitiveAST = (ast: SchemaAST.AST): boolean => {
+  if (
+    SchemaAST.isStringKeyword(ast) ||
+    SchemaAST.isNumberKeyword(ast) ||
+    SchemaAST.isBooleanKeyword(ast) ||
+    SchemaAST.isLiteral(ast)
+  ) {
+    return true
+  }
+
+  if (SchemaAST.isRefinement(ast)) {
+    return isPrimitiveAST(ast.from)
+  }
+
+  if (SchemaAST.isTransformation(ast)) {
+    return isPrimitiveAST(ast.to)
+  }
+
+  return false
+}

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",