@livestore/common 0.4.0-dev.0 → 0.4.0-dev.1

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

@@ -1,13 +1,16 @@
-import { type Nullable, shouldNeverHappen, type Writeable } from '@livestore/utils'
-import { Option, Schema, SchemaAST, type Types } from '@livestore/utils/effect'
+import { type Nullable, shouldNeverHappen } from '@livestore/utils'
+import { Option, type Schema, SchemaAST, type Types } from '@livestore/utils/effect'
 
-import { AutoIncrement, ColumnType, Default, PrimaryKeyId, Unique } from './column-annotations.ts'
+import { getColumnDefForSchema, schemaFieldsToColumns } from './column-def.ts'
 import { SqliteDsl } from './db-schema/mod.ts'
 import type { QueryBuilder } from './query-builder/mod.ts'
 import { makeQueryBuilder, QueryBuilderAstSymbol, QueryBuilderTypeId } from './query-builder/mod.ts'
 
 export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
 
+// Re-export the column definition function
+export { getColumnDefForSchema }
+
 export type StateType = 'singleton' | 'dynamic'
 
 export type DefaultSqliteTableDef = SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
@@ -398,256 +401,3 @@ export declare namespace TableDefInput {
     SchemaToColumns.FromTypes<TType, TEncoded>
   >
 }
-
-/**
- * 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.
- */
-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
-}
-
-/**
- * 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
-
-  // Check for annotations
-  const hasPrimaryKey = propertySignature
-    ? hasPropertyAnnotation<boolean>(propertySignature, PrimaryKeyId).pipe(Option.getOrElse(() => false))
-    : SchemaAST.getAnnotation<boolean>(PrimaryKeyId)(ast).pipe(Option.getOrElse(() => false))
-
-  const hasAutoIncrement = propertySignature
-    ? hasPropertyAnnotation<boolean>(propertySignature, AutoIncrement).pipe(Option.getOrElse(() => false))
-    : SchemaAST.getAnnotation<boolean>(AutoIncrement)(ast).pipe(Option.getOrElse(() => false))
-
-  const defaultValue = propertySignature
-    ? hasPropertyAnnotation<unknown>(propertySignature, Default)
-    : SchemaAST.getAnnotation<unknown>(Default)(ast)
-
-  /** Adds annotations to a column definition if they are present. */
-  const withAnnotationsIfNeeded = (columnDef: SqliteDsl.ColumnDefinition.Any): SqliteDsl.ColumnDefinition.Any => {
-    const result = { ...columnDef }
-
-    if (hasPrimaryKey) {
-      result.primaryKey = true
-    }
-
-    if (hasAutoIncrement) {
-      result.autoIncrement = true
-    }
-
-    if (Option.isSome(defaultValue)) {
-      result.default = Option.some(defaultValue.value)
-    }
-
-    return result
-  }
-
-  // Check for custom column type annotation
-  const columnTypeAnnotation = SchemaAST.getAnnotation<SqliteDsl.FieldColumnType>(ColumnType)(ast)
-  if (Option.isSome(columnTypeAnnotation)) {
-    const columnType = columnTypeAnnotation.value
-    let columnDef: SqliteDsl.ColumnDefinition.Any
-    switch (columnType) {
-      case 'text':
-        columnDef = SqliteDsl.text()
-        break
-      case 'integer':
-        columnDef = SqliteDsl.integer()
-        break
-      case 'real':
-        columnDef = SqliteDsl.real()
-        break
-      case 'blob':
-        columnDef = SqliteDsl.blob()
-        break
-      default:
-        return shouldNeverHappen(`Unsupported column type annotation: ${columnType}`)
-    }
-
-    return withAnnotationsIfNeeded(columnDef)
-  }
-
-  // Check for refinements (e.g., Schema.Int)
-  if (SchemaAST.isRefinement(ast)) {
-    // Check if this is specifically Schema.Int by looking at the identifier annotation
-    const identifier = SchemaAST.getIdentifierAnnotation(ast).pipe(Option.getOrElse(() => ''))
-    if (identifier === 'Int') {
-      return withAnnotationsIfNeeded(SqliteDsl.integer())
-    }
-    // For other refinements, check the underlying type
-    return getColumnDefForSchema(Schema.make(ast.from), propertySignature)
-  }
-
-  // Check for string types
-  if (SchemaAST.isStringKeyword(ast)) {
-    return withAnnotationsIfNeeded(SqliteDsl.text())
-  }
-
-  // Check for number types
-  if (SchemaAST.isNumberKeyword(ast)) {
-    return withAnnotationsIfNeeded(SqliteDsl.real())
-  }
-
-  // Check for boolean types
-  if (SchemaAST.isBooleanKeyword(ast)) {
-    return withAnnotationsIfNeeded(SqliteDsl.boolean())
-  }
-
-  // Check for unions (like optional or nullable)
-  if (SchemaAST.isUnion(ast)) {
-    // Check if this union contains null or undefined (making it nullable/optional)
-    let hasNull = false
-    let hasUndefined = false
-    let nonNullableType: SchemaAST.AST | undefined
-
-    for (const type of ast.types) {
-      if (SchemaAST.isUndefinedKeyword(type)) {
-        hasUndefined = true
-      } else if (SchemaAST.isLiteral(type) && type.literal === null) {
-        hasNull = true
-      } else {
-        nonNullableType = type
-      }
-    }
-
-    // If we found a non-nullable type, use it for the column definition
-    if (nonNullableType) {
-      const innerSchema = Schema.make(nonNullableType)
-      const innerColumnDef = getColumnDefForSchema(innerSchema, propertySignature)
-
-      // If the union contains null or undefined, mark as nullable
-      if (hasNull || hasUndefined) {
-        return withAnnotationsIfNeeded({
-          ...innerColumnDef,
-          nullable: true,
-        })
-      }
-
-      return withAnnotationsIfNeeded(innerColumnDef)
-    }
-  }
-
-  // Check for Date types
-  if (SchemaAST.isTransformation(ast)) {
-    // Try to map the transformation's target type
-    return getColumnDefForSchema(Schema.make(ast.to), propertySignature)
-  }
-
-  // Check for literal types
-  if (SchemaAST.isLiteral(ast)) {
-    const value = ast.literal
-    if (typeof value === 'string') {
-      return withAnnotationsIfNeeded(SqliteDsl.text())
-    } else if (typeof value === 'number') {
-      return withAnnotationsIfNeeded(SqliteDsl.real())
-    } else if (typeof value === 'boolean') {
-      return withAnnotationsIfNeeded(SqliteDsl.boolean())
-    }
-  }
-
-  // Default to JSON column for complex types
-  return withAnnotationsIfNeeded(SqliteDsl.json({ schema }))
-}

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.4.0-dev.0' as const
+export const liveStoreVersion = '0.4.0-dev.1' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.