@livestore/common 0.4.0 → 0.5.0-dev.0

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

@@ -12,19 +12,19 @@ import { SqliteDsl } from './db-schema/mod.ts'
  * Fields with both null and undefined will emit a warning as this is a lossy conversion.
  */
 export const getColumnDefForSchema = (
-  schema: Schema.Schema.AnyNoContext,
+  schema: Schema.Top,
   propertySignature?: SchemaAST.PropertySignature,
   forceNullable = false,
 ): SqliteDsl.ColumnDefinition.Any => {
   const ast = schema.ast
 
   // Extract annotations
-  const getAnnotation = <T>(annotationId: symbol): Option.Option<T> =>
+  const getAnnotation = <T>(annotationId: string): Option.Option<T> =>
     propertySignature !== undefined
       ? hasPropertyAnnotation<T>(propertySignature, annotationId)
-      : SchemaAST.getAnnotation<T>(annotationId)(ast)
+      : Option.fromUndefinedOr(SchemaAST.resolveAt<T>(annotationId)(ast))
 
-  const columnType = SchemaAST.getAnnotation<SqliteDsl.FieldColumnType>(ColumnType)(ast)
+  const columnType = Option.fromUndefinedOr(SchemaAST.resolveAt<SqliteDsl.FieldColumnType>(ColumnType)(ast))
 
   // Check if schema has null (e.g., Schema.NullOr) or undefined or if it's forced nullable (optional field)
   const isNullable = forceNullable === true || hasNull(ast) === true || hasUndefined(ast) === true
@@ -50,13 +50,13 @@ export const getColumnDefForSchema = (
 
 const hasPropertyAnnotation = <T>(
   propertySignature: SchemaAST.PropertySignature,
-  annotationId: symbol,
+  annotationId: string,
 ): Option.Option<T> => {
-  if ('annotations' in propertySignature && propertySignature.annotations !== undefined) {
-    const annotation = SchemaAST.getAnnotation<T>(annotationId)(propertySignature as any)
-    if (Option.isSome(annotation) === true) return annotation
+  const keyAnnotation = propertySignature.type.context?.annotations?.[annotationId] as T | undefined
+  if (keyAnnotation !== undefined) {
+    return Option.some(keyAnnotation)
   }
-  return SchemaAST.getAnnotation<T>(annotationId)(propertySignature.type)
+  return Option.fromUndefinedOr(SchemaAST.resolveAt<T>(annotationId)(propertySignature.type))
 }
 
 /**
@@ -72,10 +72,11 @@ export const schemaFieldsToColumns = (
   for (const prop of propertySignatures) {
     if (typeof prop.name !== 'string') continue
 
-    const fieldSchema = Schema.make(prop.type)
+    const isOptional = SchemaAST.isOptional(prop.type)
+    const fieldSchema = Schema.make<Schema.Top>(prop.type)
 
     // Warn about lossy conversion for fields with both null and undefined
-    if (prop.isOptional === true) {
+    if (isOptional === true) {
       const { hasNull, hasUndefined } = checkNullUndefined(fieldSchema.ast)
       if (hasNull === true && hasUndefined === true) {
         console.warn(`Field '${prop.name}' has both null and undefined - treating | undefined as | null`)
@@ -83,7 +84,7 @@ export const schemaFieldsToColumns = (
     }
 
     // Get column definition - pass nullable flag for optional fields
-    const columnDef = getColumnDefForSchema(fieldSchema, prop, prop.isOptional === true)
+    const columnDef = getColumnDefForSchema(fieldSchema, prop, isOptional === true)
 
     // Check for primary key and unique annotations
     const hasPrimaryKey = hasPropertyAnnotation<boolean>(prop, PrimaryKeyId).pipe(Option.getOrElse(() => false))
@@ -112,8 +113,8 @@ const checkNullUndefined = (ast: SchemaAST.AST): { hasNull: boolean; hasUndefine
   let hasUndefined = false
 
   const visit = (type: SchemaAST.AST): void => {
-    if (SchemaAST.isUndefinedKeyword(type) === true) hasUndefined = true
-    else if (SchemaAST.isLiteral(type) === true && type.literal === null) hasNull = true
+    if (SchemaAST.isUndefined(type) === true) hasUndefined = true
+    else if (SchemaAST.isNull(type) === true) hasNull = true
     else if (SchemaAST.isUnion(type) === true) type.types.forEach(visit)
   }
 
@@ -122,7 +123,7 @@ const checkNullUndefined = (ast: SchemaAST.AST): { hasNull: boolean; hasUndefine
 }
 
 const hasNull = (ast: SchemaAST.AST): boolean => {
-  if (SchemaAST.isLiteral(ast) === true && ast.literal === null) return true
+  if (SchemaAST.isNull(ast) === true) return true
   if (SchemaAST.isUnion(ast) === true) {
     return ast.types.some((type) => hasNull(type))
   }
@@ -130,7 +131,7 @@ const hasNull = (ast: SchemaAST.AST): boolean => {
 }
 
 const hasUndefined = (ast: SchemaAST.AST): boolean => {
-  if (SchemaAST.isUndefinedKeyword(ast) === true) return true
+  if (SchemaAST.isUndefined(ast) === true) return true
   if (SchemaAST.isUnion(ast) === true) {
     return ast.types.some((type) => hasUndefined(type))
   }
@@ -152,36 +153,34 @@ const getColumnForType = (columnType: string, nullable = false): SqliteDsl.Colum
   }
 }
 
-const getColumnForSchema = (schema: Schema.Schema.AnyNoContext, nullable = false): SqliteDsl.ColumnDefinition.Any => {
+const getColumnForSchema = (schema: Schema.Top, nullable = false): SqliteDsl.ColumnDefinition.Any => {
   const ast = schema.ast
   // Strip nullable wrapper to get core type
   const coreAst = stripNullable(ast)
-  const coreSchema = stripNullable(ast) === ast ? schema : Schema.make(coreAst)
+  const coreSchema = (stripNullable(ast) === ast ? schema : Schema.make(coreAst)) as Schema.Codec<any, any>
 
   // Special case: Boolean is transformed to integer in SQLite
-  if (SchemaAST.isBooleanKeyword(coreAst) === true) {
+  if (SchemaAST.isBoolean(coreAst) === true) {
     return SqliteDsl.boolean({ nullable })
   }
 
   // Get the encoded AST - what actually gets stored in SQLite
-  const encodedAst = Schema.encodedSchema(coreSchema).ast
+  const encodedAst = Schema.toEncoded(coreSchema).ast
 
   // Check if the encoded type matches SQLite native types
-  if (SchemaAST.isStringKeyword(encodedAst) === true) {
+  if (SchemaAST.isString(encodedAst) === true) {
     return SqliteDsl.text({ schema: coreSchema, nullable })
   }
 
-  if (SchemaAST.isNumberKeyword(encodedAst) === true) {
-    // Special cases for integer columns
-    const id = SchemaAST.getIdentifierAnnotation(coreAst).pipe(Option.getOrElse(() => ''))
-    if (id === 'Int' || id === 'DateFromNumber') {
+  if (SchemaAST.isNumber(encodedAst) === true) {
+    if (hasCheck(coreAst.checks, 'effect/schema/isInt') === true || hasDateRepresentation(coreAst) === true) {
       return SqliteDsl.integer({ schema: coreSchema, nullable })
     }
     return SqliteDsl.real({ schema: coreSchema, nullable })
   }
 
   if (isUint8ArraySchema(coreAst) === true || isUint8ArraySchema(encodedAst) === true) {
-    return SqliteDsl.blob({ schema: Schema.Uint8ArrayFromSelf as Schema.Schema<Uint8Array<ArrayBuffer>>, nullable })
+    return SqliteDsl.blob({ schema: coreSchema, nullable })
   }
 
   const literalColumn = getLiteralColumnDefinition(encodedAst, coreSchema, nullable, coreAst)
@@ -200,7 +199,7 @@ const stripNullable = (ast: SchemaAST.AST): SchemaAST.AST => {
 
   // Filter out null/undefined members while preserving any annotations on the union
   const coreTypes = ast.types.filter(
-    (type) => !(SchemaAST.isLiteral(type) && type.literal === null) && !SchemaAST.isUndefinedKeyword(type),
+    (type) => SchemaAST.isNull(type) === false && SchemaAST.isUndefined(type) === false,
   )
 
   if (coreTypes.length === 0 || coreTypes.length === ast.types.length) {
@@ -211,12 +210,12 @@ const stripNullable = (ast: SchemaAST.AST): SchemaAST.AST => {
     return coreTypes[0]!
   }
 
-  return SchemaAST.Union.make(coreTypes, ast.annotations)
+  return new SchemaAST.Union(coreTypes, ast.mode, ast.annotations)
 }
 
 const getLiteralColumnDefinition = (
   ast: SchemaAST.AST,
-  schema: Schema.Schema.AnyNoContext,
+  schema: Schema.Codec<any, any>,
   nullable: boolean,
   sourceAst: SchemaAST.AST,
 ): SqliteDsl.ColumnDefinition.Any | null => {
@@ -228,8 +227,7 @@ const getLiteralColumnDefinition = (
     case 'string':
       return SqliteDsl.text({ schema, nullable })
     case 'number': {
-      const id = SchemaAST.getIdentifierAnnotation(sourceAst).pipe(Option.getOrElse(() => ''))
-      if (id === 'Int' || id === 'DateFromNumber') {
+      if (hasCheck(sourceAst.checks, 'effect/schema/isInt') === true || hasDateRepresentation(sourceAst) === true) {
         return SqliteDsl.integer({ schema, nullable })
       }
 
@@ -247,6 +245,9 @@ const getLiteralColumnDefinition = (
   }
 }
 
+/** Effect's built-in date codecs expose their semantic type through the Date representation annotation. */
+const hasDateRepresentation = (ast: SchemaAST.AST): boolean => hasRepresentation(ast, 'effect/schema/Date')
+
 const extractLiteralValues = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.LiteralValue> | null => {
   if (SchemaAST.isLiteral(ast) === true) return [ast.literal]
 
@@ -255,7 +256,7 @@ const extractLiteralValues = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.Liter
     ast.types.length > 0 &&
     ast.types.every((type) => SchemaAST.isLiteral(type)) === true
   ) {
-    return ast.types.map((type) => (type as SchemaAST.Literal).literal)
+    return ast.types.map((type) => type.literal)
   }
 
   return null
@@ -264,7 +265,7 @@ const extractLiteralValues = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.Liter
 const getLiteralValueType = (
   literals: ReadonlyArray<SchemaAST.LiteralValue>,
 ): 'string' | 'number' | 'boolean' | 'bigint' | null => {
-  const literalTypes = new Set(literals.map((value) => (value === null ? 'null' : typeof value)))
+  const literalTypes = new Set(literals.map((value) => typeof value))
   if (literalTypes.size !== 1) return null
 
   const [literalType] = literalTypes
@@ -273,15 +274,49 @@ const getLiteralValueType = (
     : null
 }
 
+/**
+ * Recursively checks for Effect built-in check metadata.
+ *
+ * Checks can be attached directly as `Filter`s or nested in `FilterGroup`s when
+ * schemas compose multiple refinements, e.g. `Schema.Int.check(...)`.
+ *
+ * Effect rc.109 replaced the closed `meta` annotation with the open `representation`
+ * identity, so built-in checks are matched by their representation id.
+ */
+const hasCheck = (checks: ReadonlyArray<SchemaAST.Check<unknown>> | undefined, representationId: string): boolean => {
+  return (
+    checks?.some((check) => {
+      switch (check._tag) {
+        case 'Filter':
+          return check.annotations?.representation?.id === representationId
+        case 'FilterGroup':
+          return hasCheck(check.checks, representationId)
+      }
+    }) === true
+  )
+}
+
 const isUint8ArraySchema = (ast: SchemaAST.AST): boolean => {
-  const identifier = SchemaAST.getIdentifierAnnotation(ast)
-  if (Option.isSome(identifier) === true && identifier.value.includes('Uint8Array') === true) {
+  // `resolveAt` reads the last check's annotations, which can mask the declaration's representation.
+  if (hasRepresentation(ast, 'effect/schema/Uint8Array') === true) {
+    return true
+  }
+
+  const identifier = SchemaAST.resolveIdentifier(ast)
+  if (identifier !== undefined && identifier.includes('Uint8Array') === true) {
     return true
   }
 
-  if (SchemaAST.isTupleType(ast) === true) {
-    return ast.elements.length === 0 && ast.rest.length === 1 && SchemaAST.isNumberKeyword(ast.rest[0]!.type)
+  if (SchemaAST.isArrays(ast) === true) {
+    return ast.elements.length === 0 && ast.rest.length === 1 && SchemaAST.isNumber(ast.rest[0]!)
   }
 
   return false
 }
+
+const hasRepresentation = (ast: SchemaAST.AST, id: string): boolean => {
+  const representation = ast.annotations?.representation
+  return (
+    typeof representation === 'object' && representation !== null && 'id' in representation && representation.id === id
+  )
+}

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

@@ -28,9 +28,9 @@ const createColumn = (
       case 'text':
         return Schema.String
       case 'integer':
-        return options.defaultValue === true || options.defaultValue === false ? Schema.Boolean : Schema.Number
+        return options.defaultValue === true || options.defaultValue === false ? Schema.Boolean : Schema.Finite
       case 'real':
-        return Schema.Number
+        return Schema.Finite
       case 'blob':
         return Schema.Uint8ArrayFromBase64
       default:

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

@@ -19,7 +19,7 @@ export const makeColumnSpec = (tableAst: SqliteAst.Table) => {
   // is only valid on a single column declared as INTEGER PRIMARY KEY (column-level).
   const columnDefStrs = tableAst.columns.map((column) =>
     toSqliteColumnSpec(column, {
-      inlinePrimaryKey: hasSinglePk && column === pkColumn &&  column.primaryKey,
+      inlinePrimaryKey: hasSinglePk && column === pkColumn && column.primaryKey,
     }),
   )
 
@@ -40,7 +40,8 @@ const toSqliteColumnSpec = (column: SqliteAst.Column, opts: { inlinePrimaryKey:
   const nullableStr = opts.inlinePrimaryKey === true ? '' : column.nullable === false ? 'not null' : ''
 
   // Only include AUTOINCREMENT when it's valid: single-column INTEGER PRIMARY KEY
-  const includeAutoIncrement = opts.inlinePrimaryKey === true && column.type._tag === 'integer' && column.autoIncrement === true
+  const includeAutoIncrement =
+    opts.inlinePrimaryKey === true && column.type._tag === 'integer' && column.autoIncrement === true
 
   const pkStr = opts.inlinePrimaryKey === true ? 'primary key' : ''
   const autoIncrementStr = includeAutoIncrement === true ? 'autoincrement' : ''

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

@@ -25,7 +25,7 @@ export type Column = {
   nullable: boolean
   autoIncrement: boolean
   default: Option.Option<any>
-  schema: Schema.Schema<any>
+  schema: Schema.Codec<any, any>
 }
 
 export const column = (props: Omit<Column, '_tag'>): Column => ({ _tag: 'column', ...props })
@@ -84,14 +84,24 @@ export type DbSchema = {
 export const dbSchema = (tables: Table[]): DbSchema => ({ _tag: 'dbSchema', tables })
 
 /**
- * Helper to detect if a column is a JSON column (has parseJson transformation)
+ * Helper to detect if a column is a JSON column (encoded as a JSON string)
  */
 const isJsonColumn = (column: Column): boolean => {
   if (column.type._tag !== 'text') return false
 
-  // Check if the schema AST is a parseJson transformation
-  const ast = column.schema.ast
-  return ast._tag === 'Transformation' && ast.annotations.schemaId === SchemaAST.ParseJsonSchemaId
+  return hasJsonStringEncoding(column.schema.ast)
+}
+
+/**
+ * `SchemaTransformation.fromJsonString` is a factory since Effect rc.109, so encoding links can no
+ * longer be matched by identity. `Schema.fromJsonString` annotates its encoded side as
+ * `application/json`, which identifies the link regardless of the reviver/replacer/space options.
+ */
+const hasJsonStringEncoding = (ast: SchemaAST.AST): boolean => {
+  if (ast.encoding?.some((link) => link.to.annotations?.contentMediaType === 'application/json') === true) {
+    return true
+  }
+  return SchemaAST.isUnion(ast) === true && ast.types.some(hasJsonStringEncoding)
 }
 
 /**

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

@@ -3,77 +3,77 @@
 exports[`FieldDefs > boolean 1`] = `
 {
   "autoIncrement": false,
-  "columnType": "text",
+  "columnType": "integer",
   "default": {
     "_id": "Option",
     "_tag": "None",
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Boolean",
+    "decodedAst": "Boolean",
+    "encodedAst": "Union",
+  },
 }
 `;
 
 exports[`FieldDefs > boolean 2`] = `
 {
   "autoIncrement": false,
-  "columnType": "text",
+  "columnType": "integer",
   "default": {
     "_id": "Option",
     "_tag": "None",
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Boolean",
+    "decodedAst": "Boolean",
+    "encodedAst": "Union",
+  },
 }
 `;
 
 exports[`FieldDefs > boolean 3`] = `
 {
   "autoIncrement": false,
-  "columnType": "text",
+  "columnType": "integer",
   "default": {
     "_id": "Option",
     "_tag": "Some",
-    "value": null,
+    "value": false,
   },
-  "nullable": true,
+  "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
-}
-`;
-
-exports[`FieldDefs > boolean 4`] = `
-{
-  "autoIncrement": false,
-  "columnType": "text",
-  "default": {
-    "_id": "Option",
-    "_tag": "Some",
-    "value": "foo",
+  "schema": {
+    "ast": "Boolean",
+    "decodedAst": "Boolean",
+    "encodedAst": "Union",
   },
-  "nullable": true,
-  "primaryKey": false,
-  "schema": [Function],
 }
 `;
 
-exports[`FieldDefs > boolean 5`] = `
+exports[`FieldDefs > datetime 1`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
-    "_tag": "Some",
-    "value": "foo",
+    "_tag": "None",
   },
-  "nullable": true,
+  "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Declaration",
+    "decodedAst": "Declaration",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 6`] = `
+exports[`FieldDefs > datetime 2`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
@@ -83,11 +83,15 @@ exports[`FieldDefs > boolean 6`] = `
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Declaration",
+    "decodedAst": "Declaration",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 7`] = `
+exports[`FieldDefs > datetime 3`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
@@ -98,28 +102,34 @@ exports[`FieldDefs > boolean 7`] = `
   },
   "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 8`] = `
+exports[`FieldDefs > datetime 4`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
     "_tag": "Some",
-    "value": {
-      "name": "Bob",
-    },
+    "value": 2022-02-02T00:00:00.000Z,
   },
-  "nullable": true,
+  "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Declaration",
+    "decodedAst": "Declaration",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 9`] = `
+exports[`FieldDefs > json 1`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
@@ -129,93 +139,143 @@ exports[`FieldDefs > boolean 9`] = `
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Any",
+    "decodedAst": "Any",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 10`] = `
+exports[`FieldDefs > json 2`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
-    "_tag": "None",
+    "_tag": "Some",
+    "value": null,
   },
-  "nullable": false,
+  "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 11`] = `
+exports[`FieldDefs > json 3`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
     "_tag": "Some",
-    "value": null,
+    "value": {
+      "name": "Bob",
+    },
   },
   "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 12`] = `
+exports[`FieldDefs > text 1`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
-    "_tag": "Some",
-    "value": 2022-02-02T00:00:00.000Z,
+    "_tag": "None",
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "String",
+    "decodedAst": "String",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 13`] = `
+exports[`FieldDefs > text 2`] = `
 {
   "autoIncrement": false,
-  "columnType": "integer",
+  "columnType": "text",
   "default": {
     "_id": "Option",
     "_tag": "None",
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "String",
+    "decodedAst": "String",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 14`] = `
+exports[`FieldDefs > text 3`] = `
 {
   "autoIncrement": false,
-  "columnType": "integer",
+  "columnType": "text",
   "default": {
     "_id": "Option",
-    "_tag": "None",
+    "_tag": "Some",
+    "value": null,
   },
-  "nullable": false,
+  "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 15`] = `
+exports[`FieldDefs > text 4`] = `
 {
   "autoIncrement": false,
-  "columnType": "integer",
+  "columnType": "text",
   "default": {
     "_id": "Option",
     "_tag": "Some",
-    "value": false,
+    "value": "foo",
   },
-  "nullable": false,
+  "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
+}
+`;
+
+exports[`FieldDefs > text 5`] = `
+{
+  "autoIncrement": false,
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": "foo",
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;