fix(codegen-ts): SQLite isArray columns emit .\$type<E[]>() for typed JSON

When isArray:true on SQLite, the column maps to text("col",{mode:"json"})
which Drizzle infers as `unknown` without an explicit .\$type<>()
annotation. The downstream InferSelectModel then leaves the field
`unknown`, forcing consumers to cast back to the actual element type.

Add the chain `.\$type<E[]>()` where E is the TS element type for the
field's scalar subType (string for STRING/ENUM/CLASS/DATE/TIME/TIMESTAMP/
DECIMAL, number for INT/LONG/CURRENCY/DOUBLE/FLOAT, boolean for BOOLEAN).
Object refs leave .\$type unset — consumers layer their own richer
schema there. Postgres .array() path is untouched (already element-typed).

Surfaced by wizardsofodd.com: with this fix, src/db/generated/Wizard.ts's
`bickersWith` becomes `string[]` instead of `unknown`, matching the
payload-side Wizard interface and removing the last source of `as
unknown as` casts in the consumer.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dmealing

server/typescript/packages/codegen-ts/src/column-mapper.ts

@@ -63,6 +63,36 @@ function isSqlExprDefault(value: string): boolean {
   return SQL_EXPR_PATTERNS.some((re) => re.test(value));
 }
 
+/**
+ * For an isArray:true field stored in SQLite as text(...,{mode:"json"}), return
+ * the TS element type used in the emitted .$type<E[]>() chain. Returns undefined
+ * when the field's subType doesn't have a stable scalar TS mapping (e.g.,
+ * field.object — leave the inferred `unknown[]` so the consumer can layer a
+ * richer schema on top).
+ */
+function sqliteJsonArrayElementTsType(subType: string): string | undefined {
+  switch (subType) {
+    case FIELD_SUBTYPE_STRING:
+    case FIELD_SUBTYPE_ENUM:
+    case FIELD_SUBTYPE_CLASS:
+    case FIELD_SUBTYPE_DATE:
+    case FIELD_SUBTYPE_TIME:
+    case FIELD_SUBTYPE_TIMESTAMP:
+    case FIELD_SUBTYPE_DECIMAL:
+      return "string";
+    case FIELD_SUBTYPE_INT:
+    case FIELD_SUBTYPE_LONG:
+    case FIELD_SUBTYPE_CURRENCY:
+    case FIELD_SUBTYPE_DOUBLE:
+    case FIELD_SUBTYPE_FLOAT:
+      return "number";
+    case FIELD_SUBTYPE_BOOLEAN:
+      return "boolean";
+    default:
+      return undefined;
+  }
+}
+
 /** Map a recognized SQL expression to its canonical raw form (uppercase keywords). */
 function canonicalizeSqlExpr(value: string): string {
   const lower = value.toLowerCase();
@@ -226,6 +256,18 @@ export function mapColumnType(
     modifiers.push(".array()");
   }
 
+  // SQLite stores arrays as JSON in a text column; Drizzle's text(...,{mode:"json"})
+  // infers the column as `unknown` without a $type<T>() annotation, so consumers
+  // who pull the inferred type can't see the element type. Emit $type<E[]>()
+  // so the inferred TS type is element-precise. Postgres uses .array() above
+  // which is already element-typed by Drizzle.
+  if (dialect === "sqlite" && isArray) {
+    const elementType = sqliteJsonArrayElementTsType(subType);
+    if (elementType !== undefined) {
+      modifiers.push(`.$type<${elementType}[]>()`);
+    }
+  }
+
   if (isRequired(field)) {
     modifiers.push(".notNull()");
   }

server/typescript/packages/codegen-ts/test/column-mapper.test.ts

@@ -51,12 +51,29 @@ describe("mapColumnType — SQLite", () => {
     expect(spec.dbName).toBe("given_name");
   });
 
-  test("@isArray on string → text with mode json", () => {
+  test("@isArray on string → text with mode json and $type<string[]>() chain", () => {
     const f = metaField(FIELD_SUBTYPE_STRING, "tags");
     f.setIsArray(true);
     const spec = mapColumnType(f, "sqlite");
     expect(spec.fnName).toBe("text");
     expect(spec.fnOptions).toEqual({ mode: "json" });
+    expect(spec.modifiers).toContain(".$type<string[]>()");
+  });
+
+  test("@isArray on int → text with mode json and $type<number[]>() chain", () => {
+    const f = metaField(FIELD_SUBTYPE_INT, "scores");
+    f.setIsArray(true);
+    const spec = mapColumnType(f, "sqlite");
+    expect(spec.fnName).toBe("text");
+    expect(spec.modifiers).toContain(".$type<number[]>()");
+  });
+
+  test("@isArray on boolean → text with mode json and $type<boolean[]>() chain", () => {
+    const f = metaField(FIELD_SUBTYPE_BOOLEAN, "flags");
+    f.setIsArray(true);
+    const spec = mapColumnType(f, "sqlite");
+    expect(spec.fnName).toBe("text");
+    expect(spec.modifiers).toContain(".$type<boolean[]>()");
   });
 
   test("decimal → text with leadingComment surfacing the precision-fallback", () => {