@an5/orm 1.2.0 → 1.3.0

package/generator/src/api.ts

@@ -25,6 +25,9 @@ export { PythonGenerator } from './python-generator';
 export { DotnetGenerator } from './dotnet-generator';
 export { GolangGenerator } from './golang-generator';
 export { RustGenerator } from './rust-generator';
+export { JavaGenerator } from './java-generator';
+export { KotlinGenerator } from './kotlin-generator';
+export { SwiftGenerator } from './swift-generator';
 export { detectProvider, providerFromConfig, providerForProject } from './config';
 export { dialectFor, defaultClause, sqlLiteral } from './dialect';
 export { fieldKind } from './type-kinds';

package/generator/src/code-generator.ts

@@ -2,6 +2,13 @@ import fs from 'fs';
 import path from 'path';
 import { Model, Field, Relation } from './types';
 
+/**
+ * Types `resolveFieldType` can return that the SQL keyword table in
+ * `normalizeType` does not cover. Kept explicit so a new resolver output is a
+ * deliberate addition rather than silently becoming `any`.
+ */
+const RESOLVED_TS_TYPES = new Set(['Buffer', 'number | bigint', 'number[] | string']);
+
 export class CodeGenerator {
   constructor(private outputDir: string) {
     if (!fs.existsSync(this.outputDir)) {
@@ -249,7 +256,12 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
     if (['bytes', 'binary', 'varbinary', 'image'].includes(lowerType)) {
       return 'string';
     }
-    return 'any';
+    // `Field.type` already holds the TypeScript type the parser resolved for the
+    // provider, and the resolver returns a few types this SQL table does not list:
+    // `Buffer` (BLOB), `number | bigint` (BIGINT) and `number[] | string` (VECTOR).
+    // Those used to fall through to `any`, so the generated client silently lost the
+    // type of every byte and vector column.
+    return RESOLVED_TS_TYPES.has(type) ? type : 'any';
   }
 
   private toCamelCase(str: string): string {

package/generator/src/code-request.ts

@@ -8,9 +8,12 @@ import { PythonGenerator } from './python-generator';
 import { DotnetGenerator } from './dotnet-generator';
 import { GolangGenerator } from './golang-generator';
 import { RustGenerator } from './rust-generator';
+import { JavaGenerator } from './java-generator';
+import { KotlinGenerator } from './kotlin-generator';
+import { SwiftGenerator } from './swift-generator';
 import type { Provider } from './field-types';
 
-export const CODE_LANGUAGES = ['typescript', 'python', 'dotnet', 'golang', 'rust'] as const;
+export const CODE_LANGUAGES = ['typescript', 'python', 'dotnet', 'golang', 'rust', 'java', 'kotlin', 'swift'] as const;
 export type CodeLanguage = typeof CODE_LANGUAGES[number];
 export interface CodeRequest {
   request: string;
@@ -31,6 +34,14 @@ export function detectCodeLanguage(root: string): CodeLanguage {
   if (names.some(name => /\.(csproj|sln|slnx)$/.test(name))) candidates.push('dotnet');
   if (has('go.mod')) candidates.push('golang');
   if (has('Cargo.toml')) candidates.push('rust');
+  // Java and Kotlin are told apart by their build file, not by a directory name: a Gradle
+  // project has both a build.gradle and a pom.xml, and only one says which language it is.
+  const hasJavaBuild = has('pom.xml') || has('build.gradle') || has('build.gradle.kts');
+  if (hasJavaBuild) {
+    const kotlinMarker = names.some((name) => /\.(kt|kts)$/.test(name)) || has('settings.gradle.kts');
+    candidates.push(kotlinMarker ? 'kotlin' : 'java');
+  }
+  if (has('Package.swift')) candidates.push('swift');
   if (candidates.length !== 1) throw new Error(`Cannot select one project language (${candidates.join(', ') || 'none'}). Specify language explicitly or select the application directory.`);
   return candidates[0]!;
 }
@@ -42,7 +53,7 @@ export async function prepareCodeRequest(input: CodeRequest) {
   if (!CODE_LANGUAGES.includes(language)) throw new Error(`Unsupported language: ${language}`);
   const loaded = loadConfig(input.projectRoot);
   const output = loaded.outputs;
-  const clientOutput = { typescript: output.typescriptDir, python: path.dirname(output.pythonMetadataFile), dotnet: output.dotnetDir, golang: output.golangDir, rust: output.rustDir }[language];
+  const clientOutput = { typescript: output.typescriptDir, python: path.dirname(output.pythonMetadataFile), dotnet: output.dotnetDir, golang: output.golangDir, rust: output.rustDir, java: output.javaDir, kotlin: output.kotlinDir, swift: output.swiftDir }[language];
   const schemaPath = path.resolve(input.projectRoot, input.schemaPath);
   const schemaDir = fs.statSync(schemaPath).isDirectory() ? schemaPath : path.dirname(schemaPath);
   const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'an5-code-request-'));
@@ -62,13 +73,16 @@ export async function prepareCodeRequest(input: CodeRequest) {
       case 'dotnet': new DotnetGenerator(scratch).generate(models); break;
       case 'golang': new GolangGenerator(scratch).generate(models); break;
       case 'rust': new RustGenerator(scratch).generate(models); break;
+      case 'java': new JavaGenerator(scratch).generate(models); break;
+      case 'kotlin': new KotlinGenerator(scratch).generate(models); break;
+      case 'swift': new SwiftGenerator(scratch).generate(models); break;
     }
     const files: { path: string; content: string }[] = [];
     function collect(dir: string) {
       for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         const full = path.join(dir, entry.name);
         if (entry.isDirectory()) collect(full);
-        else if (/\.(ts|py|cs|go|rs|mod|toml)$/.test(entry.name)) files.push({ path: path.relative(scratch, full), content: fs.readFileSync(full, 'utf8') });
+        else if (/\.(ts|py|cs|go|rs|mod|toml|java|kt|swift)$/.test(entry.name)) files.push({ path: path.relative(scratch, full), content: fs.readFileSync(full, 'utf8') });
       }
     }
     collect(scratch);

package/generator/src/config.ts

@@ -41,6 +41,21 @@ export interface RustOutput {
   outputDir: string;
 }
 
+/** Java client output. */
+export interface JavaOutput {
+  outputDir: string;
+}
+
+/** Kotlin client output. */
+export interface KotlinOutput {
+  outputDir: string;
+}
+
+/** Swift client output. */
+export interface SwiftOutput {
+  outputDir: string;
+}
+
 export interface An5OrmConfig {
   /**
    * Database connection for the commands that need one — db:push, db:pull,
@@ -62,6 +77,9 @@ export interface An5OrmConfig {
     dotnet: DotnetOutput;
     golang: GolangOutput;
     rust: RustOutput;
+    java: JavaOutput;
+    kotlin: KotlinOutput;
+    swift: SwiftOutput;
   };
   pull: {
     /** Regex patterns; tables matching any of them are skipped by db:pull. */
@@ -86,6 +104,9 @@ export const DEFAULT_CONFIG: An5OrmConfig = {
     dotnet: { outputDir: 'an5Client/dotnet' },
     golang: { outputDir: 'an5Client/golang' },
     rust: { outputDir: 'an5Client/rust' },
+    java: { outputDir: 'an5Client/java' },
+    kotlin: { outputDir: 'an5Client/kotlin' },
+    swift: { outputDir: 'an5Client/swift' },
   },
   pull: {
     exclude: ['^__', '^sys\\.', '^igrations'],
@@ -105,6 +126,9 @@ export interface ResolvedOutputs {
   dotnetDir: string;
   golangDir: string;
   rustDir: string;
+  javaDir: string;
+  kotlinDir: string;
+  swiftDir: string;
 }
 
 export function resolveOutputs(config: An5OrmConfig, rootDir: string): ResolvedOutputs {
@@ -117,6 +141,9 @@ export function resolveOutputs(config: An5OrmConfig, rootDir: string): ResolvedO
     dotnetDir: resolve(config.outputs.dotnet.outputDir),
     golangDir: resolve(config.outputs.golang.outputDir),
     rustDir: resolve(config.outputs.rust.outputDir),
+    javaDir: resolve(config.outputs.java.outputDir),
+    kotlinDir: resolve(config.outputs.kotlin.outputDir),
+    swiftDir: resolve(config.outputs.swift.outputDir),
   };
 }
 
@@ -232,6 +259,9 @@ const OUTPUT_SPEC: Record<string, FieldSpec> = {
   dotnet: 'object',
   golang: 'object',
   rust: 'object',
+  java: 'object',
+  kotlin: 'object',
+  swift: 'object',
 };
 
 const OUTPUT_SECTION_SPEC: Record<string, Record<string, FieldSpec>> = {
@@ -240,6 +270,9 @@ const OUTPUT_SECTION_SPEC: Record<string, Record<string, FieldSpec>> = {
   dotnet: { outputDir: 'string' },
   golang: { outputDir: 'string' },
   rust: { outputDir: 'string' },
+  java: { outputDir: 'string' },
+  kotlin: { outputDir: 'string' },
+  swift: { outputDir: 'string' },
 };
 
 const TOP_LEVEL_SPEC: Record<string, FieldSpec> = {
@@ -317,6 +350,21 @@ export function validateConfig(raw: unknown): An5OrmConfig {
           (outputs.rust as Record<string, unknown> | undefined)?.outputDir as string ??
           DEFAULT_CONFIG.outputs.rust.outputDir,
       },
+      java: {
+        outputDir:
+          (outputs.java as Record<string, unknown> | undefined)?.outputDir as string ??
+          DEFAULT_CONFIG.outputs.java.outputDir,
+      },
+      kotlin: {
+        outputDir:
+          (outputs.kotlin as Record<string, unknown> | undefined)?.outputDir as string ??
+          DEFAULT_CONFIG.outputs.kotlin.outputDir,
+      },
+      swift: {
+        outputDir:
+          (outputs.swift as Record<string, unknown> | undefined)?.outputDir as string ??
+          DEFAULT_CONFIG.outputs.swift.outputDir,
+      },
     },
     pull: {
       exclude: (pull.exclude as string[] | undefined) ?? DEFAULT_CONFIG.pull.exclude,

package/generator/src/dialect.ts

@@ -293,13 +293,15 @@ function createDialect(provider: Provider, quote: (name: string) => string): Pus
   // destructured by a caller.
   const columnDefinition = (column: ColumnSpec): string => {
     const identity = identityKeyword(column, provider);
+    const sqlType = provider === 'sqlite' && /^VECTOR\s*(\(|$)/i.test(column.sqlType)
+      ? 'BLOB' : column.sqlType;
     // Where the identity keyword goes is not a detail: SQL Server takes it as part
     // of the column type (`INT IDENTITY(1,1)`), while SQLite only accepts it after
     // `PRIMARY KEY` and only spells the documented form `INTEGER PRIMARY KEY
     // AUTOINCREMENT`.
     const type = identity && provider !== 'sqlite'
-      ? `${quote(column.name)} ${column.sqlType} ${identity}`
-      : `${quote(column.name)} ${column.sqlType}`;
+      ? `${quote(column.name)} ${sqlType} ${identity}`
+      : `${quote(column.name)} ${sqlType}`;
     const nullable = column.isOptional ? '' : ' NOT NULL';
     const unique = column.isUnique && !column.isId ? ' UNIQUE' : '';
     const defaultSql = defaultClause(column.defaultExpr, provider);
@@ -412,4 +414,4 @@ export function defaultClause(expression: string | undefined, provider: Provider
       if (/^".*"$/.test(value)) return `DEFAULT '${value.slice(1, -1).replace(/'/g, "''")}'`;
       return `DEFAULT ${value}`;
   }
-}
+}

package/generator/src/dotnet-generator.ts

@@ -305,6 +305,7 @@ using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
+using System.Linq;
 using System.Reflection;
 using System.Text.Json;
 using An5Orm.Entities;
@@ -393,11 +394,41 @@ namespace An5Orm
         {
             var p = cmd.CreateParameter();
             p.ParameterName = (name ?? "").TrimStart('@');
-            p.Value = value ?? DBNull.Value;
+            p.Value = Bindable(value) ?? DBNull.Value;
             cmd.Parameters.Add(p);
             return p;
         }
 
+        /// <summary>
+        /// Converts a value into something the provider can bind.
+        /// </summary>
+        /// <remarks>
+        /// A <c>VECTOR(n)</c> column is transmitted as a JSON array over TDS, so a float or
+        /// double array is written in that form. The array itself is not bindable: the
+        /// provider has no mapping for it, and the failure names the array rather than the
+        /// column it was meant for.
+        /// </remarks>
+        public static object Bindable(object value)
+        {
+            // \`float[]\` and \`double[]\` are listed separately rather than through a shared
+            // \`IEnumerable<double>\`: an array of value type is not covariant, so
+            // \`float[]\` does not convert to it.
+            if (value is float[] floats) return FormatVector(floats.Select(v => (double)v));
+            if (value is double[] doubles) return FormatVector(doubles);
+            return value;
+        }
+
+        /// <summary>Renders a vector as the JSON array SQL Server expects.</summary>
+        public static string FormatVector(IEnumerable<double> vector)
+        {
+            var parts = new List<string>();
+            foreach (var value in vector)
+            {
+                parts.Add(value.ToString("R", System.Globalization.CultureInfo.InvariantCulture));
+            }
+            return "[" + string.Join(", ", parts) + "]";
+        }
+
         /// <summary>Quotes an identifier for the dialect.</summary>
         public static string Quote(string name, An5Dialect dialect)
         {
@@ -1024,6 +1055,60 @@ namespace An5Orm
         /// property would otherwise fail to set. A value that cannot be
         /// converted is skipped rather than aborting the whole read.
         /// </summary>
+        /// <summary>
+        /// Reads a stored vector into the \`float[]\` an entity declares.
+        /// </summary>
+        /// <remarks>
+        /// A \`VECTOR(n)\` column arrives as a JSON array over TDS, so the JSON form is
+        /// what is parsed. A float32 BLOB is also accepted because that is what the SQLite
+        /// provider stores in the same column. Returns <c>null</c> for anything else, which
+        /// leaves the property at its default rather than aborting the whole read.
+        /// </remarks>
+        private static float[] DecodeVectorColumn(object value)
+        {
+            if (value is float[] already) return already;
+            if (value is double[] asDouble)
+            {
+                var fromDouble = new float[asDouble.Length];
+                for (int i = 0; i < asDouble.Length; i++) fromDouble[i] = (float)asDouble[i];
+                return fromDouble;
+            }
+
+            string text = value as string;
+            byte[] bytes = value as byte[];
+            if (bytes != null && bytes.Length > 0 && bytes[0] != (byte)'[' && bytes.Length % 4 == 0)
+            {
+                var fromBlob = new float[bytes.Length / 4];
+                for (int i = 0; i < fromBlob.Length; i++)
+                {
+                    int offset = i * 4;
+                    uint bits = (uint)(bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24));
+                    fromBlob[i] = BitConverter.ToSingle(BitConverter.GetBytes(bits), 0);
+                }
+                return fromBlob;
+            }
+            if (text == null && bytes != null)
+            {
+                text = System.Text.Encoding.UTF8.GetString(bytes);
+            }
+            if (text == null) return null;
+
+            var open = text.IndexOf('[');
+            var close = text.LastIndexOf(']');
+            if (open < 0 || close <= open) return null;
+            var body = text.Substring(open + 1, close - open - 1).Trim();
+            if (body.Length == 0) return null;
+
+            var parts = body.Split(',');
+            var parsed = new float[parts.Length];
+            for (int i = 0; i < parts.Length; i++)
+            {
+                if (!float.TryParse(parts[i].Trim(), System.Globalization.NumberStyles.Float,
+                    System.Globalization.CultureInfo.InvariantCulture, out parsed[i])) return null;
+            }
+            return parsed;
+        }
+
         private static void SetValue(System.Reflection.PropertyInfo prop, object target, object value)
         {
             var wanted = prop.PropertyType;
@@ -1041,6 +1126,17 @@ namespace An5Orm
                     prop.SetValue(target, Convert.ChangeType(value, underlying));
                     return;
                 }
+                // A \`VECTOR(n)\` column is transmitted as a JSON array over TDS, which no
+                // converter bridges to the \`float[]\` the entity declares.
+                if (wanted == typeof(float[]))
+                {
+                    var vector = DecodeVectorColumn(value);
+                    if (vector != null)
+                    {
+                        prop.SetValue(target, vector);
+                        return;
+                    }
+                }
                 if (value is string text && wanted == typeof(Guid)) { prop.SetValue(target, Guid.Parse(text)); return; }
                 if (value is string when && wanted == typeof(DateTime)) { prop.SetValue(target, DateTime.Parse(when, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.RoundtripKind)); return; }
                 prop.SetValue(target, Convert.ChangeType(value, wanted));

package/generator/src/field-types.ts

@@ -266,6 +266,9 @@ export const PROVIDER_FIELD_TYPES: Record<Provider, Readonly<Record<string, TsTy
     // Everything else
     JSON: 'any',
     UUID: 'string',
+    // Stored as a BLOB of little-endian float32: a third of the JSON text it replaces,
+    // and what the adapters' in-database distance functions read. A column already
+    // holding JSON text keeps working, because the adapters decode both.
     VECTOR: 'number[] | string',
   },
 

package/generator/src/golang-generator.ts

@@ -189,6 +189,7 @@ func GetDefaultConnectionString() string {
     content += this.generateWhereBuilder();
     content += this.generateCrudMethods();
     content += this.generateVectorSearch();
+    content += this.generateVectorHelpers();
     content += this.generateHelpers();
 
     // NOTE: per-model ORM types live in each `<Model>.go` file.
@@ -417,9 +418,18 @@ func (c *TableClient[T]) queryAndScan(ctx context.Context, query string, args ..
 \t\tvar item T
 \t\tval := reflect.ValueOf(&item).Elem()
 \t\tscanArgs := make([]interface{}, len(cols))
+\t\tvectorCols := make([]bool, len(cols))
 \t\tfor i, colName := range cols {
 \t\t\tfieldVal := findFieldByDbTag(val, colName)
 \t\t\tif fieldVal.IsValid() && fieldVal.CanSet() {
+\t\t\t\t// A \`VECTOR(n)\` column is stored as bytes, which database/sql cannot
+\t\t\t\t// scan into a slice, so it is read as bytes and decoded afterwards.
+\t\t\t\tif isVectorGoType(fieldVal.Type()) {
+\t\t\t\t\tvar raw []byte
+\t\t\t\t\tscanArgs[i] = &raw
+\t\t\t\t\tvectorCols[i] = true
+\t\t\t\t\tcontinue
+\t\t\t\t}
 \t\t\t\tscanArgs[i] = fieldVal.Addr().Interface()
 \t\t\t} else {
 \t\t\t\tvar unused interface{}
@@ -429,6 +439,20 @@ func (c *TableClient[T]) queryAndScan(ctx context.Context, query string, args ..
 \t\tif err := rows.Scan(scanArgs...); err != nil {
 \t\t\treturn nil, err
 \t\t}
+\t\tfor i, isVector := range vectorCols {
+\t\t\tif !isVector {
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tdecoded, ok := decodeVectorBytes(*(scanArgs[i].(*[]byte)))
+\t\t\tif !ok {
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tfieldVal := findFieldByDbTag(val, cols[i])
+\t\t\tif !fieldVal.IsValid() || !fieldVal.CanSet() {
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tsetVectorField(fieldVal, decoded)
+\t\t}
 \t\tresults = append(results, item)
 \t}
 \tif err := rows.Err(); err != nil {
@@ -437,6 +461,161 @@ func (c *TableClient[T]) queryAndScan(ctx context.Context, query string, args ..
 \treturn results, nil
 }
 
+`;
+  }
+
+  /**
+   * The vector codec the generated client needs on both sides of a query.
+   *
+   * A \`VECTOR(n)\` column stores float32 bytes, which is a third of the JSON text it
+   * replaces and is what the in-database distance functions read. A column written
+   * before that encoding holds JSON text, so both are still accepted on the way in.
+   */
+  private generateVectorHelpers(): string {
+    return `// bytesPerVectorFloat is the width of one stored vector component.
+const bytesPerVectorFloat = 4
+
+// isVectorGoType reports whether a model field is a vector column, which the
+// generator declares as a float32 slice, optionally behind a pointer because the
+// column is nullable.
+func isVectorGoType(t reflect.Type) bool {
+\treturn vectorSliceType(t) != nil
+}
+
+// vectorSliceType returns the slice type a vector field holds, or nil for any
+// other field. A pointer to a slice is unwrapped so both the nullable and the
+// required spelling are recognised.
+func vectorSliceType(t reflect.Type) reflect.Type {
+\tif t.Kind() == reflect.Ptr {
+\t\tt = t.Elem()
+\t}
+\tif t.Kind() == reflect.Slice && t.Elem().Kind() == reflect.Float32 {
+\t\treturn t
+\t}
+\treturn nil
+}
+
+// vectorComponents reads a vector field as float64 components.
+//
+// A field can arrive as JSON text, as a slice, or behind a pointer to either, and a
+// pointer is how the generator spells a nullable column. Anything else is not a vector.
+func vectorComponents(field reflect.Value) []float64 {
+\tfor field.Kind() == reflect.Ptr {
+\t\tif field.IsNil() {
+\t\t\treturn nil
+\t\t}
+\t\tfield = field.Elem()
+\t}
+\tswitch {
+\tcase field.Kind() == reflect.String:
+\t\tvar parsed []float64
+\t\tif err := json.Unmarshal([]byte(field.String()), &parsed); err != nil {
+\t\t\treturn nil
+\t\t}
+\t\treturn parsed
+\tcase field.Kind() == reflect.Slice:
+\t\tout := make([]float64, field.Len())
+\t\tfor i := range out {
+\t\t\tout[i] = field.Index(i).Float()
+\t\t}
+\t\treturn out
+\tdefault:
+\t\treturn nil
+\t}
+}
+
+// setVectorField stores decoded components into a vector field, matching whether
+// the field holds the slice directly or behind a pointer.
+func setVectorField(field reflect.Value, values []float64) {
+\tsliceType := vectorSliceType(field.Type())
+\tif sliceType == nil {
+\t\treturn
+\t}
+\tslice := reflect.MakeSlice(sliceType, len(values), len(values))
+\tfor i, value := range values {
+\t\tslice.Index(i).SetFloat(value)
+\t}
+\tif field.Kind() == reflect.Ptr {
+\t\tptr := reflect.New(sliceType)
+\t\tptr.Elem().Set(slice)
+\t\tfield.Set(ptr)
+\t\treturn
+\t}
+\tfield.Set(slice)
+}
+
+// encodeVectorArg converts a vector field into the bytes the column stores.
+//
+// database/sql accepts only a fixed set of types, so a slice otherwise reaches the
+// driver as an error. Values that already arrived as stored form pass through.
+func encodeVectorArg(value interface{}) interface{} {
+\tswitch v := value.(type) {
+\tcase *[]float32:
+\t\tif v == nil {
+\t\t\treturn nil
+\t\t}
+\t\treturn encodeVectorFloats(floatsFrom32(*v))
+\tcase []float32:
+\t\treturn encodeVectorFloats(floatsFrom32(v))
+\tcase *[]float64:
+\t\tif v == nil {
+\t\t\treturn nil
+\t\t}
+\t\treturn encodeVectorFloats(*v)
+\tcase []float64:
+\t\treturn encodeVectorFloats(v)
+\tdefault:
+\t\treturn value
+\t}
+}
+
+func floatsFrom32(values []float32) []float64 {
+\tout := make([]float64, len(values))
+\tfor i, value := range values {
+\t\tout[i] = float64(value)
+\t}
+\treturn out
+}
+
+// encodeVectorFloats writes float32 values little-endian, which is the order the
+// stored bytes are read back in.
+func encodeVectorFloats(values []float64) []byte {
+\tout := make([]byte, len(values)*bytesPerVectorFloat)
+\tfor i, value := range values {
+\t\toffset := i * bytesPerVectorFloat
+\t\tbits := math.Float32bits(float32(value))
+\t\tout[offset] = byte(bits)
+\t\tout[offset+1] = byte(bits >> 8)
+\t\tout[offset+2] = byte(bits >> 16)
+\t\tout[offset+3] = byte(bits >> 24)
+\t}
+\treturn out
+}
+
+// decodeVectorBytes reads a stored vector: float32 bytes, legacy JSON text, or
+// nothing at all.
+func decodeVectorBytes(raw []byte) ([]float64, bool) {
+\tif len(raw) == 0 {
+\t\treturn nil, false
+\t}
+\t// JSON text is not a multiple of four bytes once encoded and starts with '[',
+\t// so the two are told apart by length and first byte.
+\tif raw[0] == '[' || len(raw)%bytesPerVectorFloat != 0 {
+\t\tvar parsed []float64
+\t\tif err := json.Unmarshal(raw, &parsed); err != nil || len(parsed) == 0 {
+\t\t\treturn nil, false
+\t\t}
+\t\treturn parsed, true
+\t}
+\tout := make([]float64, len(raw)/bytesPerVectorFloat)
+\tfor i := range out {
+\t\toffset := i * bytesPerVectorFloat
+\t\tbits := uint32(raw[offset]) | uint32(raw[offset+1])<<8 | uint32(raw[offset+2])<<16 | uint32(raw[offset+3])<<24
+\t\tout[i] = float64(math.Float32frombits(bits))
+\t}
+\treturn out, true
+}
+
 `;
   }
 
@@ -657,7 +836,7 @@ func (c *TableClient[T]) Create(ctx context.Context, entity *T) (*T, error) {
 \t\tfieldVal := val.Field(i)
 \t\tif !fieldVal.IsZero() {
 \t\t\tcols = append(cols, c.quoteName(dbTag))
-\t\t\targs = append(args, fieldVal.Interface())
+\t\t\targs = append(args, encodeVectorArg(fieldVal.Interface()))
 \t\t\tphs = append(phs, c.ph(len(args)))
 \t\t}
 \t}
@@ -704,7 +883,7 @@ func (c *TableClient[T]) Update(ctx context.Context, entity *T) (*T, error) {
 \t\t\tidVal = fieldVal.Interface()
 \t\t\tidCol = dbTag
 \t\t} else if !fieldVal.IsZero() {
-\t\t\targs = append(args, fieldVal.Interface())
+\t\t\targs = append(args, encodeVectorArg(fieldVal.Interface()))
 \t\t\tsets = append(sets, c.quoteName(dbTag)+" = "+c.ph(len(args)))
 \t\t}
 \t}
@@ -1053,13 +1232,9 @@ func (c *TableClient[T]) VectorSearch(ctx context.Context, vector []float64, opt
 \t\t\tcontinue
 \t\t}
 
-\t\tvar rowVec []float64
-\t\tif fieldVal.Kind() == reflect.String {
-\t\t\t_ = json.Unmarshal([]byte(fieldVal.String()), &rowVec)
-\t\t} else if fieldVal.Kind() == reflect.Slice {
-\t\t\tfor i := 0; i < fieldVal.Len(); i++ {
-\t\t\t\trowVec = append(rowVec, fieldVal.Index(i).Float())
-\t\t\t}
+\t\trowVec := vectorComponents(fieldVal)
+\t\tif len(rowVec) == 0 {
+\t\t\tcontinue
 \t\t}
 \t\tif len(rowVec) != len(vector) {
 \t\t\tcontinue

package/generator/src/index.ts

@@ -8,6 +8,9 @@ import { PythonGenerator } from './python-generator';
 import { DotnetGenerator } from './dotnet-generator';
 import { GolangGenerator } from './golang-generator';
 import { RustGenerator } from './rust-generator';
+import { JavaGenerator } from './java-generator';
+import { KotlinGenerator } from './kotlin-generator';
+import { SwiftGenerator } from './swift-generator';
 
 import fs from 'fs';
 
@@ -69,6 +72,9 @@ async function main() {
   const outputDotnetDir = config.outputs.dotnetDir;
   const outputGolangDir = config.outputs.golangDir;
   const outputRustDir = config.outputs.rustDir;
+  const outputJavaDir = config.outputs.javaDir;
+  const outputKotlinDir = config.outputs.kotlinDir;
+  const outputSwiftDir = config.outputs.swiftDir;
   const generateMetadata = config.config.generation.generateMetadata;
 
   console.log('🚀 Starting ORM generation...');
@@ -83,6 +89,9 @@ async function main() {
     clearGeneratedFiles(outputDotnetDir, '.cs');
     clearGeneratedFiles(outputGolangDir, '.go');
     clearGeneratedFiles(path.join(outputRustDir, 'src'), '.rs');
+    clearGeneratedFiles(outputJavaDir, '.java');
+    clearGeneratedFiles(outputKotlinDir, '.kt');
+    clearGeneratedFiles(path.join(outputSwiftDir, 'Sources'), '.swift');
     const pythonDirEarly = path.dirname(outputPythonMetadataPath);
     clearGeneratedPythonFiles(pythonDirEarly);
     if (config.config.generation.generateMetadata && fs.existsSync(outputMetadataPath)) {
@@ -129,6 +138,18 @@ async function main() {
     rustGen.generate(models);
     console.log(`✨ Generated Rust client in ${outputRustDir}`);
 
+    const javaGen = new JavaGenerator(outputJavaDir);
+    javaGen.generate(models);
+    console.log(`✨ Generated Java client in ${outputJavaDir}`);
+
+    const kotlinGen = new KotlinGenerator(outputKotlinDir);
+    kotlinGen.generate(models);
+    console.log(`✨ Generated Kotlin client in ${outputKotlinDir}`);
+
+    const swiftGen = new SwiftGenerator(outputSwiftDir);
+    swiftGen.generate(models);
+    console.log(`✨ Generated Swift client in ${outputSwiftDir}`);
+
     console.log('✅ ORM generation completed successfully.');
   } catch (error) {
     // Print every bad field type with its provider, instead of the parser's