@inflector/optima 1.0.0 → 1.0.2

package/src/table.ts

@@ -1,926 +0,0 @@
-import type { DuckDBConnection, DuckDBValue } from "@duckdb/node-api";
-import {
-  SQLBuilder,
-  type ColumnBuilder,
-  type Infer,
-  type InferAdd,
-  type Prettify,
-} from "./schema";
-import { createFluentBuilder } from "./fluent";
-import {
-  createProxyHandler,
-  createQueryBuilder,
-  createQueryBuilderOne,
-  type FluentQueryBuilder,
-  type FluentQueryBuilderOne,
-  type MapToFalse,
-  type QueryMethods,
-  type QueryOneMethods,
-} from "./Qfluent";
-
-// ---------------------------------------------------------
-// 1. OPERATOR DEFINITIONS (Unchanged)
-// ---------------------------------------------------------
-
-export const OPS = [
-  "eq",
-  "ne",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "like",
-  "notLike",
-  "in",
-  "notIn",
-  "is",
-  "isNot",
-  "between",
-  "notBetween",
-  "startsWith",
-  "endsWith",
-  "contains",
-  "regexp",
-  "notRegexp",
-] as const;
-
-export type OpKey = (typeof OPS)[number];
-
-// ---------------------------------------------------------
-// 2. CONDITION BUILDER TYPES (Unchanged)
-// ---------------------------------------------------------
-
-type ConditionNode = {
-  type: "condition" | "and" | "or";
-  op?: OpKey;
-  value?: any;
-  left?: ConditionNode;
-  right?: ConditionNode;
-};
-
-export interface ConditionBuilder<T> {
-  eq(value: T): ConditionBuilder<T>;
-  ne(value: T): ConditionBuilder<T>;
-  gt(value: T): ConditionBuilder<T>;
-  gte(value: T): ConditionBuilder<T>;
-  lt(value: T): ConditionBuilder<T>;
-  lte(value: T): ConditionBuilder<T>;
-  in(value: T[]): ConditionBuilder<T>;
-  notIn(value: T[]): ConditionBuilder<T>;
-  between(value: [T, T]): ConditionBuilder<T>;
-  notBetween(value: [T, T]): ConditionBuilder<T>;
-  is(value: T | null): ConditionBuilder<T>;
-  isNot(value: T | null): ConditionBuilder<T>;
-  like(value: string): ConditionBuilder<T>;
-  notLike(value: string): ConditionBuilder<T>;
-  startsWith(value: string): ConditionBuilder<T>;
-  endsWith(value: string): ConditionBuilder<T>;
-  contains(value: string): ConditionBuilder<T>;
-  regexp(value: string): ConditionBuilder<T>;
-  notRegexp(value: string): ConditionBuilder<T>;
-  and(other: ConditionBuilder<T>): ConditionBuilder<T>;
-  or(other: ConditionBuilder<T>): ConditionBuilder<T>;
-  __getNode(): ConditionNode;
-}
-
-class ConditionBuilderImpl<T> implements ConditionBuilder<T> {
-  private node: ConditionNode;
-
-  constructor(node: ConditionNode) {
-    this.node = node;
-  }
-
-  private createOp(op: OpKey, value: any): ConditionBuilder<T> {
-    return new ConditionBuilderImpl<T>({
-      type: "condition",
-      op,
-      value,
-    });
-  }
-
-  eq(value: T): ConditionBuilder<T> {
-    return this.createOp("eq", value);
-  }
-  ne(value: T): ConditionBuilder<T> {
-    return this.createOp("ne", value);
-  }
-  gt(value: T): ConditionBuilder<T> {
-    return this.createOp("gt", value);
-  }
-  gte(value: T): ConditionBuilder<T> {
-    return this.createOp("gte", value);
-  }
-  lt(value: T): ConditionBuilder<T> {
-    return this.createOp("lt", value);
-  }
-  lte(value: T): ConditionBuilder<T> {
-    return this.createOp("lte", value);
-  }
-  in(value: T[]): ConditionBuilder<T> {
-    return this.createOp("in", value);
-  }
-  notIn(value: T[]): ConditionBuilder<T> {
-    return this.createOp("notIn", value);
-  }
-  between(value: [T, T]): ConditionBuilder<T> {
-    return this.createOp("between", value);
-  }
-  notBetween(value: [T, T]): ConditionBuilder<T> {
-    return this.createOp("notBetween", value);
-  }
-  is(value: T | null): ConditionBuilder<T> {
-    return this.createOp("is", value);
-  }
-  isNot(value: T | null): ConditionBuilder<T> {
-    return this.createOp("isNot", value);
-  }
-  like(value: string): ConditionBuilder<T> {
-    return this.createOp("like", value);
-  }
-  notLike(value: string): ConditionBuilder<T> {
-    return this.createOp("notLike", value);
-  }
-  startsWith(value: string): ConditionBuilder<T> {
-    return this.createOp("startsWith", value);
-  }
-  endsWith(value: string): ConditionBuilder<T> {
-    return this.createOp("endsWith", value);
-  }
-  contains(value: string): ConditionBuilder<T> {
-    return this.createOp("contains", value);
-  }
-  regexp(value: string): ConditionBuilder<T> {
-    return this.createOp("regexp", value);
-  }
-  notRegexp(value: string): ConditionBuilder<T> {
-    return this.createOp("notRegexp", value);
-  }
-  and(other: ConditionBuilder<T>): ConditionBuilder<T> {
-    return new ConditionBuilderImpl<T>({
-      type: "and",
-      left: this.node,
-      right: other.__getNode(),
-    });
-  }
-
-  or(other: ConditionBuilder<T>): ConditionBuilder<T> {
-    return new ConditionBuilderImpl<T>({
-      type: "or",
-      left: this.node,
-      right: other.__getNode(),
-    });
-  }
-
-  __getNode(): ConditionNode {
-    return this.node;
-  }
-}
-
-export function cond<T>(): ConditionBuilder<T> {
-  return new ConditionBuilderImpl<T>({ type: "condition" }) as any;
-}
-
-// Exports for standalone operators
-export const eq = <T>(value: T) => cond<T>().eq(value);
-export const ne = <T>(value: T) => cond<T>().ne(value);
-export const gt = <T>(value: T) => cond<T>().gt(value);
-export const gte = <T>(value: T) => cond<T>().gte(value);
-export const lt = <T>(value: T) => cond<T>().lt(value);
-export const lte = <T>(value: T) => cond<T>().lte(value);
-export const inOp = <T>(value: T[]) => cond<T>().in(value);
-export const notIn = <T>(value: T[]) => cond<T>().notIn(value);
-export const between = <T>(value: [T, T]) => cond<T>().between(value);
-export const notBetween = <T>(value: [T, T]) => cond<T>().notBetween(value);
-export const is = <T>(value: T | null) => cond<T>().is(value);
-export const isNot = <T>(value: T | null) => cond<T>().isNot(value);
-export const like = <T>(value: string) => cond<T>().like(value);
-export const notLike = <T>(value: string) => cond<T>().notLike(value);
-export const startsWith = <T>(value: string) => cond<T>().startsWith(value);
-export const endsWith = <T>(value: string) => cond<T>().endsWith(value);
-export const contains = <T>(value: string) => cond<T>().contains(value);
-export const regexp = <T>(value: string) => cond<T>().regexp(value);
-export const notRegexp = <T>(value: string) => cond<T>().notRegexp(value);
-
-// ---------------------------------------------------------
-// 3. WHERE TYPE DEFINITIONS (Unchanged)
-// ---------------------------------------------------------
-
-export type FieldQuery<T> =
-  // If it's ConditionBuilder already, allow it directly
-  T extends ConditionBuilder<infer U>
-  ? T
-  : // Arrays should be passed as is (for IN, etc), not recursed
-  T extends Array<any>
-  ? T | ConditionBuilder<T>
-  : // Date is an object in JS, but we treat it as a primitive for SQL
-  T extends Date
-  ? T | ConditionBuilder<T>
-  : // For objects (Structs), allow recursion OR a condition on the whole struct
-  T extends object
-  ? { [K in keyof T]?: FieldQuery<T[K]> } | ConditionBuilder<T>
-  : // Primitives
-  T | ConditionBuilder<T>;
-
-export type Where<Schema> = {
-  [K in keyof Schema]?: FieldQuery<Schema[K]>;
-};
-
-// ---------------------------------------------------------
-// 4. SQL GENERATION UTILITIES (Unchanged)
-// ---------------------------------------------------------
-
-const escape = (val: any): string => {
-  if (val === null || val === undefined) return "NULL";
-  if (typeof val === "string") return `'${val.replace(/'/g, "''")}'`;
-  if (val instanceof Date) return `'${val.toISOString()}'`;
-  if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
-  if (typeof val === "object")
-    return `'${JSON.stringify(val).replace(/'/g, "''")}'`;
-  return String(val);
-};
-
-const SQL_GENERATORS: Record<OpKey, (col: string, val: any) => string> = {
-  eq: (c, v) => `${c} = ${escape(v)}`,
-  ne: (c, v) => `${c} != ${escape(v)}`,
-  gt: (c, v) => `${c} > ${escape(v)}`,
-  gte: (c, v) => `${c} >= ${escape(v)}`,
-  lt: (c, v) => `${c} < ${escape(v)}`,
-  lte: (c, v) => `${c} <= ${escape(v)}`,
-  in: (c, v) => `${c} IN (${(v as any[]).map(escape).join(", ")})`,
-  notIn: (c, v) => `${c} NOT IN (${(v as any[]).map(escape).join(", ")})`,
-  between: (c, v) => `${c} BETWEEN ${escape(v[0])} AND ${escape(v[1])}`,
-  notBetween: (c, v) => `${c} NOT BETWEEN ${escape(v[0])} AND ${escape(v[1])}`,
-  is: (c, v) => (v === null ? `${c} IS NULL` : `${c} IS ${escape(v)}`),
-  isNot: (c, v) =>
-    v === null ? `${c} IS NOT NULL` : `${c} IS NOT ${escape(v)}`,
-  like: (c, v) => `${c} LIKE ${escape(v)}`,
-  notLike: (c, v) => `${c} NOT LIKE ${escape(v)}`,
-  startsWith: (c, v) => `${c} LIKE ${escape(v + "%")}`,
-  endsWith: (c, v) => `${c} LIKE ${escape("%" + v)}`,
-  contains: (c, v) => `${c} LIKE ${escape("%" + v + "%")}`,
-  regexp: (c, v) => `regexp_matches(${c}, ${escape(v)})`,
-  notRegexp: (c, v) => `NOT regexp_matches(${c}, ${escape(v)})`,
-};
-
-export type TableSchema<T> = T extends OptimaTable<infer Schema>
-  ? Prettify<Infer<Schema>>
-  : never;
-
-// --- Extension Type Helpers ---
-
-type GetRefSchema<Col> = Col extends ColumnBuilder<any, any, infer Ref>
-  ? Ref
-  : Col extends { config: { reference?: { ref: string; isMany: boolean } } }
-  ? never
-  : never;
-
-type IsManyRef<RS> = RS extends { readonly __refKind: "many" } ? true : false;
-
-type HasAnyManyRef<TDef> = true extends {
-  [K in keyof TDef]: GetRefSchema<TDef[K]> extends never
-  ? never
-  : IsManyRef<GetRefSchema<TDef[K]>>;
-}[keyof TDef]
-  ? true
-  : false;
-
-export type Extension<SourceDef, TargetTable> = TargetTable extends OptimaTable<
-  infer TargetDef
->
-  ? TargetDef extends { __tableName: infer Name }
-  ? Name extends string
-  ? HasAnyManyRef<SourceDef> extends true
-  ? { [K in `$${Name}`]: Infer<TargetDef>[] }
-  : { [K in `$${Name}`]: Infer<TargetDef> }
-  : {}
-  : {}
-  : {};
-
-type Unsubscribe = () => void;
-export class OptimaTable<TDef extends Record<string, any> = any> {
-  private Name: string;
-  private Connection: DuckDBConnection;
-  private Columns: TDef;
-  private listeners = new Set<
-    (change: {
-      event: "Add" | "AddMany" | "Delete" | "Update";
-      data: Partial<Infer<TDef>>;
-      time: Date;
-    }) => void
-  >();
-  private constructor(
-    name: string,
-    Columns: TDef,
-    Connection: DuckDBConnection
-  ) {
-    this.Name = name;
-    const filteredCols: any = { ...Columns };
-    if ("__tableName" in filteredCols) {
-      delete filteredCols["__tableName"];
-    }
-    this.Columns = filteredCols;
-    this.Connection = Connection;
-  }
-
-  protected notifyChange(change: any) {
-    this.listeners.forEach((listener) => listener(change));
-  }
-
-  /**
-   * Subscribe to changes to the table.
-   * The callback receives the latest change as its argument.
-   * Returns an unsubscribe function.
-   */
-  Subscribe(
-    fn: (change: {
-      event: "Add" | "AddMany" | "Delete" | "Update";
-      data: Partial<Infer<TDef>>;
-      time: Date;
-    }) => void
-  ): Unsubscribe {
-    this.listeners.add(fn);
-    return () => {
-      this.listeners.delete(fn);
-    };
-  }
-
-  private async InitTable() {
-    const SQL = SQLBuilder.BuildTable(this.Name, this.Columns);
-    await this.Connection.run(SQL);
-  }
-
-  static async create<T extends Record<string, ColumnBuilder<any, any>>>(
-    name: string,
-    Columns: T,
-    Connection: DuckDBConnection
-  ): Promise<OptimaTable<T>> {
-    const table = new OptimaTable(name, Columns, Connection);
-    await table.InitTable();
-    return table;
-  }
-
-  // ---------------------------------------------------------
-  // UPDATED: Get() now uses the Fluent Factory
-  // ---------------------------------------------------------
-  Get(): FluentQueryBuilder<
-    TDef,
-    Infer<TDef>,
-    MapToFalse<QueryMethods<TDef>> & { extended: false }
-  > {
-    return createQueryBuilder(this);
-  }
-
-  // ---------------------------------------------------------
-  // UPDATED: GetOne() now uses the Fluent Factory
-  // ---------------------------------------------------------
-  GetOne(): FluentQueryBuilderOne<
-    TDef,
-    Infer<TDef>,
-    MapToFalse<QueryOneMethods<TDef>> & { extended: false }
-  > {
-    return createQueryBuilderOne(this);
-  }
-
-  Exist() {
-    type TSchema = Infer<TDef>;
-    return createFluentBuilder<
-      {
-        where: Where<TSchema>;
-      },
-      boolean
-    >(async (data) => {
-      const whereClause = this.BuildWhereClause(data.where);
-      const sql = `SELECT 1 FROM ${this.Name}${whereClause} LIMIT 1`;
-
-      const Result: Record<string, DuckDBValue>[] = await (
-        await this.Connection.run(sql)
-      ).getRowObjects();
-
-      return Result.length > 0;
-    });
-  }
-
-  /**
-   * Add a single record.
-   * Returns: TSchema[] (containing the inserted record if returning is true)
-   */
-  Add(record: InferAdd<TDef>) {
-    type TSchema = Infer<TDef>;
-    return createFluentBuilder<
-      {
-        returning: boolean;
-      },
-      TSchema[]
-    >(async (data) => {
-      this.Validate(record);
-      record = this.Transform(record);
-      const { sql } = this.BuildInsert(this.Name, [record], data.returning);
-      const Result: Record<string, DuckDBValue>[] = await (
-        await this.Connection.run(sql)
-      ).getRowObjects();
-      const Res = this.FormatOut(Result) as TSchema[];
-      if (Res.length != 0) {
-        if (data.returning) {
-          this.notifyChange({ event: "Add", data: Res, time: new Date() });
-        } else {
-          this.notifyChange({
-            event: "Add",
-            data: await this.GetOne().where(record as any),
-            time: new Date(),
-          });
-        }
-      }
-      return Res;
-    });
-  }
-
-  /**
-   * Add multiple records.
-   * Returns: TSchema[]
-   */
-  AddMany(records: InferAdd<TDef>[]) {
-    type TSchema = Infer<TDef>;
-    return createFluentBuilder<
-      {
-        returning: boolean;
-      },
-      TSchema[]
-    >(async (data) => {
-      records.forEach((v) => this.Validate(v));
-      const transformedRecords = records.map((v) => this.Transform(v));
-      const { sql } = this.BuildInsert(
-        this.Name,
-        transformedRecords,
-        data.returning
-      );
-      const Result: Record<string, DuckDBValue>[] = await (
-        await this.Connection.run(sql)
-      ).getRowObjects();
-      const Res = this.FormatOut(Result) as TSchema[];
-      if (Res.length != 0) {
-        if (data.returning) {
-          this.notifyChange({ event: "AddMany", data: Res, time: new Date() });
-        } else {
-          const Added = transformedRecords;
-          // Use Promise.all to retrieve the added records
-          const addedPromises = Added.map(
-            async (record) => await this.GetOne().where(record as any)
-          );
-          const addedRecords = await Promise.all(addedPromises);
-          this.notifyChange({
-            event: "Add",
-            data: addedRecords,
-            time: new Date(),
-          });
-        }
-      }
-      return Res;
-    });
-  }
-
-  /**
-   * Update records.
-   * Returns: TSchema[]
-   */
-  Update(record: Partial<Infer<TDef>>) {
-    type TSchema = Infer<TDef>;
-    return createFluentBuilder<
-      {
-        where: Where<TSchema>;
-        returning: boolean;
-      },
-      TSchema[]
-    >(async (data) => {
-      this.Validate(record);
-      record = this.Transform(record);
-      const PotentialyUpdated = await this.Get().where(record as any);
-      if (PotentialyUpdated.length == 0) return [];
-      else {
-        const { sql } = this.BuildUpdate(this.Name, record, data);
-        const Result: Record<string, DuckDBValue>[] = await (
-          await this.Connection.run(sql)
-        ).getRowObjects();
-        if (Result.length != 0) {
-          if (data.returning) {
-            this.notifyChange({ event: "AddMany", data: Result, time: new Date() });
-          } else {
-            const Updated = PotentialyUpdated as any[];
-            const UpdatedPromises = Updated.map(
-              async (record: any) => await this.GetOne().where(record as any)
-            );
-            const UpdatedRecords = await Promise.all(UpdatedPromises);
-            this.notifyChange({
-              event: "Add",
-              data: UpdatedRecords,
-              time: new Date(),
-            });
-          }
-        }
-        return (data.returning ? this.FormatOut(Result) : Result) as TSchema[];
-      }
-
-    });
-  }
-
-  /**
-   * Delete records.
-   * Returns: TSchema | undefined (The code logic returns index [0], implies single delete or returning first)
-   */
-  Delete() {
-    type TSchema = Infer<TDef>;
-    return createFluentBuilder<
-      {
-        where: Where<TSchema>;
-        returning: boolean;
-      },
-      TSchema | undefined
-    >(async (data) => {
-      // Find what would be potentially deleted using the where clause
-      const PotentiallyDeleted = await this.Get().where(data.where as any);
-      if (PotentiallyDeleted.length == 0) return undefined;
-      const { sql } = this.BuildDelete(this.Name, { ...data });
-      const Result: Record<string, DuckDBValue>[] = await (
-        await this.Connection.run(sql)
-      ).getRowObjects();
-
-      if (Result.length != 0) {
-        if (data.returning) {
-          this.notifyChange({ event: "DeleteMany", data: Result, time: new Date() });
-        } else {
-          const DeletedRecords = PotentiallyDeleted as any[];
-          this.notifyChange({
-            event: "Delete",
-            data: DeletedRecords,
-            time: new Date(),
-          });
-        }
-      }
-      const formatted = this.FormatOut(Result) as TSchema[];
-      return formatted[0];
-    });
-  }
-
-  Count() {
-    type TSchema = Infer<TDef>;
-    return createFluentBuilder<{ where: Where<TSchema> }, number>(
-      async (data) => {
-        const whereClause = this.BuildWhereClause(data.where);
-        const sql = `SELECT COUNT(*) as count FROM ${this.Name}${whereClause}`;
-        const result = await (await this.Connection.run(sql)).getRowObjects();
-        // @ts-ignore
-        return Number(result[0].count);
-      }
-    );
-  }
-
-  /**
-   * Auto-resolves relationships based on schema 'reference'
-   */
-  private ResolveJoin(
-    targetTable: OptimaTable<any>
-  ): { sql: string; isMany: boolean } | null {
-    const myName = this.Name;
-    const targetName = targetTable.Name;
-
-    const getRef = (builder: any) => {
-      // @ts-ignore
-      const refConf = builder.config.reference;
-      if (typeof refConf === "string") return { ref: refConf, isMany: false };
-      if (refConf && typeof refConf === "object") return refConf;
-      return null;
-    };
-
-    // // 1. They reference Me
-    // for (const [colName, builder] of Object.entries(targetTable.Columns)) {
-    //   const config = getRef(builder);
-    //   if (config && config.ref) {
-    //     const [refTable, refCol] = config.ref.split(".");
-    //     if (refTable === myName) {
-    //       // if (config.isMany) {
-    //       //   return `list_contains(${targetName}.${colName}, ${myName}.${refCol})`;
-    //       // }
-    //       return `${targetName}.${colName} = ${myName}.${refCol}`;
-    //     }
-    //   }
-    // }
-
-    // 2. I reference Them
-    for (const [colName, builder] of Object.entries(this.Columns)) {
-      const config = getRef(builder);
-      if (config && config.ref) {
-        const [refTable, refCol] = config.ref.split(".");
-        if (refTable === targetName) {
-          // if (config.isMany) {
-          //   return `list_contains(${myName}.${colName}, ${targetName}.${refCol})`;
-          // }
-          return {
-            sql: `${myName}.${colName} = ${targetName}.${refCol}`,
-            isMany: config.isMany,
-          };
-        }
-      }
-    }
-
-    console.warn(
-      `Could not resolve relationship between ${myName} and ${targetName}`
-    );
-    return null;
-  }
-  // -- Validator --
-  private Validate(data: any) {
-    const Cols = Object.fromEntries(
-      //@ts-ignore
-      Object.entries(this.Columns).map(([col, val]) => [col, val.config])
-    );
-    for (const [field, config] of Object.entries(Cols)) {
-      // For partial updates, skip validation if key is missing
-      if (data[field] === undefined) continue;
-
-      if ("validate" in config && typeof config.validate === "function") {
-        const fn = config.validate;
-        if (!fn(data[field])) {
-          throw new Error(
-            `Validation failed for field '${field}' : The value '${JSON.stringify(
-              data[field]
-            )}' doesn't pass the validate function`
-          );
-        }
-      }
-    }
-  }
-  // -- Transformer --
-  private Transform(data: any) {
-    const Cols = Object.fromEntries(
-      //@ts-ignore
-      Object.entries(this.Columns).map(([col, val]) => [col, val.config])
-    );
-    const transformed: any = { ...data };
-    for (const [field, config] of Object.entries(Cols)) {
-      // For partial updates, skip transform if key is missing
-      if (transformed[field] === undefined) continue;
-
-      if ("transform" in config && typeof config.transform === "function") {
-        const fn = config.transform;
-        transformed[field] = fn(transformed[field]);
-      }
-    }
-    return transformed;
-  }
-  // --- SHARED: Where Clause Builder ---
-  private BuildWhereClause = (
-    where: Where<Infer<TDef>> | undefined
-  ): string => {
-    if (!where) return "";
-
-    const conditions: string[] = [];
-
-    // Helper to generate SQL for specific operators
-    const nodeToSQL = (node: ConditionNode, colName: string): string => {
-      if (node.type === "condition" && node.op) {
-        return SQL_GENERATORS[node.op](colName, node.value);
-      } else if (node.type === "and" && node.left && node.right) {
-        return `(${nodeToSQL(node.left, colName)} AND ${nodeToSQL(
-          node.right,
-          colName
-        )})`;
-      } else if (node.type === "or" && node.left && node.right) {
-        return `(${nodeToSQL(node.left, colName)} OR ${nodeToSQL(
-          node.right,
-          colName
-        )})`;
-      }
-      return "";
-    };
-
-    // Recursive function to handle nested objects (Structs)
-    const processLevel = (currentWhere: any, pathPrefix: string) => {
-      for (const key of Object.keys(currentWhere)) {
-        const val = currentWhere[key];
-
-        // Build the dot-notation column name (e.g. "address.city")
-        const colName = pathPrefix ? `${pathPrefix}.${key}` : key;
-
-        // 1. Skip undefined values
-        if (val === undefined) continue;
-
-        // 2. Check for ConditionBuilder (e.g., eq(5), is(null))
-        if (
-          val &&
-          typeof val === "object" &&
-          "__getNode" in val &&
-          typeof val.__getNode === "function"
-        ) {
-          const node = (val as ConditionBuilder<any>).__getNode();
-          const sql = nodeToSQL(node, colName);
-          if (sql) conditions.push(sql);
-        }
-        // 3. Check for Nested Object (Struct recursion)
-        // Must exclude Arrays and Dates which are treated as values
-        else if (
-          val &&
-          typeof val === "object" &&
-          !Array.isArray(val) &&
-          !(val instanceof Date)
-        ) {
-          processLevel(val, colName);
-        }
-        // 4. Direct Value (Implicit Equality)
-        else {
-          conditions.push(SQL_GENERATORS.eq(colName, val));
-        }
-      }
-    };
-
-    processLevel(where, "");
-
-    if (conditions.length > 0) {
-      return ` WHERE ${conditions.join(" AND ")}`;
-    }
-    return "";
-  };
-
-  private BuildSelect = (
-    TableName: string,
-    options: {
-      limit?: number;
-      orderBy?: [keyof TDef | Array<keyof TDef>, "ASC" | "DESC"];
-      offset?: number;
-      groupBy?: Array<keyof TDef>;
-      where: Where<Infer<TDef>>;
-      extend?: OptimaTable<any> | OptimaTable<any>[];
-    }
-  ) => {
-    const { limit, orderBy, offset, groupBy, where, extend } = options;
-
-    // 1. Base Columns
-    let selectColumns = `${TableName}.*`;
-
-    // 2. Extended Columns (DuckDB Correlated Subquery)
-    if (extend) {
-      const extensions = Array.isArray(extend) ? extend : [extend];
-
-      for (const extTable of extensions) {
-        const joinLogic = this.ResolveJoin(extTable);
-        if (joinLogic) {
-          selectColumns += `, (SELECT ${joinLogic.isMany ? "list(" : ""}${extTable.Name
-            }${joinLogic.isMany ? ")" : ""} FROM ${extTable.Name} WHERE ${joinLogic.sql
-            }) AS "$${extTable.Name}"`;
-        }
-      }
-    }
-
-    let query = `SELECT ${selectColumns} FROM ${TableName}`;
-
-    query += this.BuildWhereClause(where);
-
-    if (groupBy && groupBy.length > 0)
-      query += ` GROUP BY ${groupBy.join(", ")}`;
-
-    if (orderBy) {
-      const [columns, direction] = orderBy;
-      const columnStr = Array.isArray(columns) ? columns.join(", ") : columns;
-      query += ` ORDER BY ${String(columnStr)} ${direction}`;
-    }
-
-    if (limit !== undefined && limit !== null) query += ` LIMIT ${limit}`;
-    if (offset !== undefined && offset !== null) query += ` OFFSET ${offset}`;
-
-    return { sql: query, args: [] };
-  };
-
-  private BuildInsert = (
-    TableName: string,
-    Records: InferAdd<TDef>[],
-    isReturning: boolean
-  ) => {
-    const columnKeys = Object.keys(this.Columns);
-    const columnsHeader = `(${columnKeys.join(", ")})`;
-    const valuesBlock = Records.map((r) => {
-      const orderedValues = columnKeys.map((key) => {
-        let v = (r as any)[key];
-        if (v == null && this.Columns[key].config.default) {
-          v = this.Columns[key].config.default();
-        }
-        return escape(v);
-      });
-      return `(${orderedValues.join(",")})`;
-    }).join(",\n");
-    const sql = `INSERT INTO ${TableName} ${columnsHeader} VALUES \n${valuesBlock}${isReturning ? "\nRETURNING *" : ""
-      };`;
-
-    return { sql: sql };
-  };
-
-  private BuildUpdate = (
-    TableName: string,
-    changes: Partial<Infer<TDef>>,
-    options: {
-      where: Where<Infer<TDef>>;
-      returning: boolean;
-    }
-  ) => {
-    const { where, returning } = options;
-
-    const setClauses: string[] = [];
-    for (const [key, value] of Object.entries(changes)) {
-      if (value !== undefined) {
-        setClauses.push(`${key} = ${escape(value)}`);
-      }
-    }
-
-    if (setClauses.length === 0) {
-      throw new Error("No fields provided to update.");
-    }
-
-    let query = `UPDATE ${TableName} SET ${setClauses.join(", ")}`;
-
-    query += this.BuildWhereClause(where);
-
-    if (returning) {
-      query += " RETURNING *";
-    }
-
-    return { sql: query, args: [] };
-  };
-
-  private BuildDelete = (
-    TableName: string,
-    options: {
-      where: Where<Infer<TDef>>;
-      returning: boolean;
-    }
-  ) => {
-    const { where, returning } = options;
-    let query = `DELETE FROM ${TableName}`;
-
-    query += this.BuildWhereClause(where);
-
-    if (returning) {
-      query += " RETURNING *";
-    }
-
-    return { sql: query, args: [] };
-  };
-
-  // Helper to handle the deep recursion
-  private parseRecursive = (value: any): any => {
-    // 1. Handle Null/Undefined
-    if (value === null || value === undefined) {
-      return value;
-    }
-
-    // 2. Handle Dates (return as is, don't try to recurse properties)
-    if (value instanceof Date) {
-      return value;
-    }
-
-    // 3. Handle Arrays (recurse over every item)
-    if (Array.isArray(value)) {
-      return value.map((item) => this.parseRecursive(item));
-    }
-
-    // 4. Handle Objects (DuckDB structs, maps, or generic objects)
-    if (typeof value === "object") {
-      // DuckDB specific: If it has an 'entries' property, unwrap it and recurse
-      // @ts-ignore
-      if (value.entries !== undefined) {
-        // @ts-ignore
-        return this.parseRecursive(value.entries);
-      }
-
-      // DuckDB specific: If it has an 'items' property (lists), unwrap it and recurse
-      // @ts-ignore
-      if (value.items !== undefined) {
-        // @ts-ignore
-        return this.parseRecursive(value.items);
-      }
-
-      // Standard Object: recurse over all keys
-      const parsedObj: Record<string, any> = {};
-      for (const [k, v] of Object.entries(value)) {
-        parsedObj[k] = this.parseRecursive(v);
-      }
-      return parsedObj;
-    }
-
-    // 5. Primitives (string, number, boolean)
-    return value;
-  };
-
-  private FormatOut = (data: Record<string, DuckDBValue>[]) => {
-    return data.map((row) => {
-      const formatted: Record<string, any> = {};
-
-      for (const [key, value] of Object.entries(row)) {
-        if (key.startsWith("$") && value === null) {
-          formatted[key] = [];
-          continue;
-        }
-
-        // 2. Recursively parse everything else
-        formatted[key] = this.parseRecursive(value);
-      }
-      return formatted;
-    });
-  };
-}