Add and use SchemaOptions (#569)

- The backup & batch programs still have a lax/strict switch. However
all the tables now use the option set to set how strict they are.
- They default to .strict since the programs did.
- Next step will be to add control for each table to the programs.
- This reverts #532.

Sources/iTunes/Array+DB.swift

@@ -9,12 +9,12 @@ import Foundation
 
 extension Array where Element == Track {
   func database(
-    storage: DatabaseStorage, loggingToken: String?, schemaConstrainsts: SchemaConstraints
+    storage: DatabaseStorage, loggingToken: String?, schemaOptions: SchemaOptions
   ) async throws -> Data {
     let dbEncoder = try TracksDBEncoder(
       storage: storage, rowEncoder: self.rowEncoder(loggingToken), loggingToken: loggingToken)
     do {
-      try await dbEncoder.encode(schemaConstrainsts: schemaConstrainsts)
+      try await dbEncoder.encode(schemaOptions: schemaOptions)
       let data = try await dbEncoder.data()
       await dbEncoder.close()
       return data

Sources/iTunes/Array+TracksSqlData.swift

@@ -8,9 +8,9 @@
 import Foundation
 
 extension Array where Element == Track {
-  func sqlData(loggingToken: String?, schemaConstraints: SchemaConstraints) throws -> Data {
+  func sqlData(loggingToken: String?, schemaOptions: SchemaOptions) throws -> Data {
     let encoder = TracksSQLSourceEncoder()
     return try encoder.encode(
-      self, loggingToken: loggingToken, schemaConstraints: schemaConstraints)
+      self, loggingToken: loggingToken, schemaOptions: schemaOptions)
   }
 }

Sources/iTunes/BackupCommand.swift

@@ -137,7 +137,7 @@ public struct BackupCommand: AsyncParsableCommand {
 
     try await destination.context(outputFile: outputFile).emit(
       tracks, branch: "main", tagPrefix: tagPrefix, version: Self.configuration.version,
-      schemaConstraints: schemaConstraints)
+      schemaOptions: schemaConstraints.schemaOptions)
   }
 
   public init() {}  // This is public and empty to help the compiler.

Sources/iTunes/Batch/Batch.swift

@@ -15,7 +15,7 @@ enum Batch: CaseIterable {
 extension Batch {
   func build(
     _ configuration: GitTagData.Configuration, outputDirectory: URL,
-    schemaConstraints: SchemaConstraints
+    schemaOptions: SchemaOptions
   ) async throws {
     var patchedTracksData = try await GitTagData(configuration: configuration)
       .transformTaggedTracks {
@@ -29,7 +29,7 @@ extension Batch {
         }()
 
         return try await destination.data(
-          for: $1, loggingToken: "batch-\($0)", schemaConstraints: schemaConstraints)
+          for: $1, loggingToken: "batch-\($0)", schemaOptions: schemaOptions)
       }
 
     let pathExtension = {

Sources/iTunes/Batch/BatchCommand.swift

@@ -63,7 +63,8 @@ public struct BatchCommand: AsyncParsableCommand {
     let configuration = GitTagData.Configuration(
       directory: gitDirectory, tagPrefix: tagPrefix, fileName: Self.fileName)
     try await batch.build(
-      configuration, outputDirectory: outputDirectory, schemaConstraints: schemaConstraints)
+      configuration, outputDirectory: outputDirectory,
+      schemaOptions: schemaConstraints.schemaOptions)
   }
 
   public init() {}  // This is public and empty to help the compiler.

Sources/iTunes/Destination+Data.swift

@@ -8,17 +8,17 @@
 import Foundation
 
 extension Destination {
-  func data(for tracks: [Track], loggingToken: String?, schemaConstraints: SchemaConstraints)
+  func data(for tracks: [Track], loggingToken: String?, schemaOptions: SchemaOptions)
     async throws -> Data
   {
     switch self {
     case .json, .jsonGit:
       try tracks.jsonData()
     case .sqlCode:
-      try tracks.sqlData(loggingToken: loggingToken, schemaConstraints: schemaConstraints)
+      try tracks.sqlData(loggingToken: loggingToken, schemaOptions: schemaOptions)
     case .db:
       try await tracks.database(
-        storage: .memory, loggingToken: loggingToken, schemaConstrainsts: schemaConstraints)
+        storage: .memory, loggingToken: loggingToken, schemaOptions: schemaOptions)
     }
   }
 }

Sources/iTunes/Destination+Tracks.swift

@@ -39,7 +39,7 @@ extension Destination {
 
   func emit(
     _ tracks: [Track], branch: String, tagPrefix: String, version: String,
-    schemaConstraints: SchemaConstraints
+    schemaOptions: SchemaOptions
   ) async throws {
     enum DataExportError: Error {
       case noTracks
@@ -52,7 +52,7 @@ extension Destination {
     let tracks = tracks.sorted()
 
     let data = try await self.data(
-      for: tracks, loggingToken: nil, schemaConstraints: schemaConstraints)
+      for: tracks, loggingToken: nil, schemaOptions: schemaOptions)
 
     if let outputFile = self.url {
       try await self.fileWriter(

Sources/iTunes/SchemaConstraints+LaxSchemaOptions.swift

@@ -0,0 +1,17 @@
+//
+//  SchemaConstraints+SchemaOptions.swift
+//  itunes_json
+//
+//  Created by Greg Bolsinga on 12/25/24.
+//
+
+extension SchemaConstraints {
+  var schemaOptions: SchemaOptions {
+    switch self {
+    case .strict:
+      .strictSchema
+    case .lax:
+      .laxSchema
+    }
+  }
+}

Sources/iTunes/SchemaOptions.swift

@@ -0,0 +1,27 @@
+//
+//  SchemaOptions.swift
+//  itunes_json
+//
+//  Created by Greg Bolsinga on 12/25/24.
+//
+
+import Foundation
+
+struct SchemaOptions: OptionSet {
+  let rawValue: UInt
+
+  private static let laxArtist = SchemaOptions(rawValue: 1 << 0)
+  private static let laxAlbum = SchemaOptions(rawValue: 1 << 1)
+  private static let laxSong = SchemaOptions(rawValue: 1 << 2)
+  private static let laxPlays = SchemaOptions(rawValue: 1 << 3)
+
+  static let strictSchema = SchemaOptions()
+  static let laxSchema: SchemaOptions = [
+    Self.laxArtist, Self.laxAlbum, Self.laxSong, Self.laxPlays,
+  ]
+
+  var artistConstraints: SchemaConstraints { self.contains(.laxArtist) ? .lax : .strict }
+  var albumConstraints: SchemaConstraints { self.contains(.laxAlbum) ? .lax : .strict }
+  var songConstraints: SchemaConstraints { self.contains(.laxSong) ? .lax : .strict }
+  var playsConstraints: SchemaConstraints { self.contains(.laxPlays) ? .lax : .strict }
+}

Sources/iTunes/TracksDBEncoder.swift

@@ -42,13 +42,15 @@ struct TracksDBEncoder {
       rowEncoder.playTableBuilder(songLookup), schemaConstraints: schemaConstrainsts)
   }
 
-  func encode(schemaConstrainsts: SchemaConstraints) async throws {
+  func encode(schemaOptions: SchemaOptions) async throws {
     try await db.execute("PRAGMA foreign_keys = ON;")
-    let artistLookup = try await emitArtists(schemaConstrainsts: .strict)
-    let albumLookup = try await emitAlbums(schemaConstrainsts: schemaConstrainsts)
+    let artistLookup = try await emitArtists(schemaConstrainsts: schemaOptions.artistConstraints)
+    let albumLookup = try await emitAlbums(schemaConstrainsts: schemaOptions.albumConstraints)
     let songLookup = try await emitSongs(
-      artistLookup: artistLookup, albumLookup: albumLookup, schemaConstrainsts: schemaConstrainsts)
-    try await emitPlays(songLookup: songLookup, schemaConstrainsts: schemaConstrainsts)
+      artistLookup: artistLookup, albumLookup: albumLookup,
+      schemaConstrainsts: schemaOptions.songConstraints)
+    try await emitPlays(
+      songLookup: songLookup, schemaConstrainsts: schemaOptions.playsConstraints)
     try await db.execute(rowEncoder.views)
   }
 

Sources/iTunes/TracksSQLSourceEncoder.swift

@@ -15,38 +15,42 @@ struct TracksSQLSourceEncoder {
       self.rowEncoder = rowEncoder
     }
 
-    private var tableBuilders: [any TableBuilder] {
+    private func tableBuilders(schemaOptions: SchemaOptions) -> [(
+      any TableBuilder, SchemaConstraints
+    )] {
       [
-        rowEncoder.artistTableBuilder, rowEncoder.albumTableBuilder, rowEncoder.songTableBuilder(),
-        rowEncoder.playTableBuilder(),
+        (rowEncoder.artistTableBuilder, schemaOptions.artistConstraints),
+        (rowEncoder.albumTableBuilder, schemaOptions.albumConstraints),
+        (rowEncoder.songTableBuilder(), schemaOptions.songConstraints),
+        (rowEncoder.playTableBuilder(), schemaOptions.playsConstraints),
       ]
     }
 
-    fileprivate func sqlStatements(schemaConstraints: SchemaConstraints) -> String {
+    fileprivate func sqlStatements(schemaOptions: SchemaOptions) -> String {
       (["PRAGMA foreign_keys = ON;"]
-        + tableBuilders.flatMap {
-          var statements = [$0.schema(constraints: schemaConstraints)]
+        + tableBuilders(schemaOptions: schemaOptions).flatMap {
+          var statements = [$0.schema(constraints: $1)]
           statements.append(contentsOf: $0.statements.map { "\($0)" }.sorted())
           return statements
         } + [rowEncoder.views].compactMap { $0 }).joined(separator: "\n")
     }
   }
 
   private func encode(
-    _ tracks: [Track], loggingToken: String?, schemaConstraints: SchemaConstraints
+    _ tracks: [Track], loggingToken: String?, schemaOptions: SchemaOptions
   ) -> String {
     let encoder = Encoder(rowEncoder: tracks.rowEncoder(loggingToken))
-    return encoder.sqlStatements(schemaConstraints: schemaConstraints)
+    return encoder.sqlStatements(schemaOptions: schemaOptions)
   }
 
-  func encode(_ tracks: [Track], loggingToken: String?, schemaConstraints: SchemaConstraints) throws
+  func encode(_ tracks: [Track], loggingToken: String?, schemaOptions: SchemaOptions) throws
     -> Data
   {
     enum TracksSQLSourceEncoderError: Error {
       case cannotMakeData
     }
     guard
-      let data = encode(tracks, loggingToken: loggingToken, schemaConstraints: schemaConstraints)
+      let data = encode(tracks, loggingToken: loggingToken, schemaOptions: schemaOptions)
         .data(using: .utf8)
     else {
       throw TracksSQLSourceEncoderError.cannotMakeData