@inflector/optima 1.0.1 → 1.0.2

package/dist/index.js

@@ -1,3 +1,1155 @@
-export * from "./database";
-export * from "./schema";
-export { eq, ne, gt, gte, lt, lte, inOp, notIn, between, notBetween, is, isNot, like, notLike, startsWith, endsWith, contains, regexp, notRegexp, cond } from "./table";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Array: () => Array2,
+  BigInt: () => BigInt,
+  Boolean: () => Boolean,
+  Bytes: () => Bytes,
+  Color: () => Color,
+  DateType: () => DateType,
+  Email: () => Email,
+  Enum: () => Enum,
+  Float: () => Float,
+  GeoArea: () => GeoArea,
+  GeoPoint: () => GeoPoint,
+  Int: () => Int,
+  Json: () => Json,
+  OptimaDB: () => OptimaDB,
+  Password: () => Password,
+  SQLBuilder: () => SQLBuilder,
+  Slug: () => Slug,
+  Table: () => Table,
+  Text: () => Text,
+  Timestamp: () => Timestamp,
+  Uuid: () => Uuid,
+  between: () => between,
+  cond: () => cond,
+  contains: () => contains,
+  endsWith: () => endsWith,
+  eq: () => eq,
+  gt: () => gt,
+  gte: () => gte,
+  inOp: () => inOp,
+  is: () => is,
+  isNot: () => isNot,
+  like: () => like,
+  lt: () => lt,
+  lte: () => lte,
+  ne: () => ne,
+  notBetween: () => notBetween,
+  notIn: () => notIn,
+  notLike: () => notLike,
+  notRegexp: () => notRegexp,
+  refHelpers: () => refHelpers,
+  regexp: () => regexp,
+  startsWith: () => startsWith
+});
+
+// src/database.ts
+import { DuckDBInstance } from "@duckdb/node-api";
+
+// src/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  Array: () => Array2,
+  BigInt: () => BigInt,
+  Boolean: () => Boolean,
+  Bytes: () => Bytes,
+  Color: () => Color,
+  DateType: () => DateType,
+  Email: () => Email,
+  Enum: () => Enum,
+  Float: () => Float,
+  GeoArea: () => GeoArea,
+  GeoPoint: () => GeoPoint,
+  Int: () => Int,
+  Json: () => Json,
+  Password: () => Password,
+  SQLBuilder: () => SQLBuilder,
+  Slug: () => Slug,
+  Table: () => Table,
+  Text: () => Text,
+  Timestamp: () => Timestamp,
+  Uuid: () => Uuid,
+  refHelpers: () => refHelpers
+});
+__reExport(schema_exports, zod_star);
+import * as z from "zod";
+import * as zod_star from "zod";
+var refHelpers = {
+  one: (ref) => ref,
+  many: (ref) => ref
+};
+var ColumnImpl = class _ColumnImpl {
+  constructor(config = {}) {
+    this.config = {};
+    this.config = config;
+  }
+  next(key, value = true) {
+    return new _ColumnImpl({ ...this.config, [key]: value });
+  }
+  SQlType(val) {
+    return this.next("SQlType", val);
+  }
+  primaryKey() {
+    return this.next("primaryKey");
+  }
+  notnull() {
+    return this.next("notnull");
+  }
+  unique() {
+    return this.next("unique");
+  }
+  default(val) {
+    return this.next("default", val);
+  }
+  defaultNow() {
+    return this.next("defaultNow");
+  }
+  reference(c) {
+    const result = c(refHelpers);
+    const isManyRef = result?.[/* @__PURE__ */ Symbol.for("__refType")] === "many" || typeof result === "object" && result !== null && "__refType" in result;
+    const actualRef = result;
+    let refName = "";
+    if (actualRef?.__parent && actualRef?.__fieldName) {
+      refName = `${actualRef.__parent}.${actualRef.__fieldName}`;
+    } else {
+      const code = c.toString();
+      const match = code.match(/(?:one|many)\s*\(\s*([^)]+)\s*\)/);
+      if (match && match[1]) {
+        const refPart = match[1].trim();
+        if (refPart.includes(".")) {
+          refName = refPart;
+        }
+      }
+    }
+    const codeStr = c.toString();
+    const isMany = codeStr.includes("many(");
+    const nextConfig = { ...this.config, reference: { ref: refName, isMany } };
+    return new _ColumnImpl(nextConfig);
+  }
+  validate(fn) {
+    return this.next("validate", fn);
+  }
+  transform(fn) {
+    return this.next("transform", fn);
+  }
+  deprecated() {
+    return this.next("deprecated");
+  }
+  STRUCTType(val) {
+    return this.next("STRUCTType", val);
+  }
+};
+var Column = (conf) => {
+  return new ColumnImpl(conf);
+};
+var Int = () => Column().SQlType("INTEGER");
+var BigInt = () => Column().SQlType("BIGINT");
+var Float = () => Column().SQlType("FLOAT");
+var Boolean = () => Column().SQlType(
+  "BOOLEAN"
+);
+var Text = () => Column().SQlType("VARCHAR");
+var Uuid = () => Column().SQlType("VARCHAR");
+var DateType = () => Column().SQlType("DATE");
+var Timestamp = () => Column().SQlType("TIMESTAMP");
+var Enum = (vals) => {
+  const isString = typeof vals[0] === "string";
+  return Column().validate((v) => vals.includes(v)).SQlType(isString ? "VARCHAR" : "INTEGER");
+};
+var zodToDuckDBType = (zodType) => {
+  const def = zodType?._def;
+  if (def && (def.typeName === "ZodOptional" || def.typeName === "ZodNullable")) {
+    return zodToDuckDBType(def.innerType);
+  }
+  if (def && def.typeName === "ZodDefault") {
+    return zodToDuckDBType(def.innerType);
+  }
+  if (zodType instanceof z.ZodString) return "VARCHAR";
+  if (zodType instanceof z.ZodNumber) return "INTEGER";
+  if (zodType instanceof z.ZodBoolean) return "BOOLEAN";
+  if (zodType instanceof z.ZodDate) return "TIMESTAMP";
+  if (zodType instanceof z.ZodBigInt) return "BIGINT";
+  if ("element" in (def ?? {})) {
+    const innerType = zodToDuckDBType(def.element);
+    return `${innerType}[]`;
+  }
+  if ("shape" in (def ?? {})) {
+    const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+    const structParts = Object.entries(shape).map(([key, value]) => {
+      const fieldType = zodToDuckDBType(value);
+      return `${key} ${fieldType}`;
+    });
+    return `STRUCT(${structParts.join(", ")})`;
+  }
+  return "VARCHAR";
+};
+var Json = (obj) => {
+  const zodObj = z.object(obj);
+  const duckDBStructString = zodToDuckDBType(zodObj);
+  const col = Column().SQlType("STRUCT");
+  return col.STRUCTType(duckDBStructString);
+};
+var Array2 = (schema) => {
+  const innerType = zodToDuckDBType(schema);
+  const col = Column().SQlType("LIST");
+  return col.STRUCTType(`${innerType}[]`);
+};
+var Email = () => Column().SQlType("VARCHAR").validate((v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v));
+var Slug = () => Column().SQlType("VARCHAR").validate((v) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(v));
+var Color = () => Column().SQlType("VARCHAR").validate((v) => /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(v));
+var Bytes = () => Column().SQlType("BLOB");
+var Password = () => Column().SQlType(
+  "VARCHAR"
+);
+var GeoPoint = () => Column().SQlType("STRUCT");
+var GeoArea = () => Column().SQlType("STRUCT");
+var Table = (name, fields) => {
+  for (const [key, value] of Object.entries(fields)) {
+    Object.assign(value, { __parent: name, __fieldName: key });
+  }
+  return { ...fields, __tableName: name };
+};
+var GetFieldConfig = (f) => {
+  return f.config;
+};
+var SQLBuilder = class {
+  static BuildField(name, f) {
+    const FieldConfig = GetFieldConfig(f);
+    let sql = `${name} ${FieldConfig.SQlType || "TEXT"}`;
+    if ((FieldConfig.SQlType == "STRUCT" || FieldConfig.SQlType == "LIST") && FieldConfig.STRUCTType) {
+      sql = `${name} ${FieldConfig.STRUCTType}`;
+    }
+    if (FieldConfig.primaryKey) sql += " PRIMARY KEY";
+    if (FieldConfig.notnull) sql += " NOT NULL";
+    if (FieldConfig.unique) sql += " UNIQUE";
+    if (FieldConfig.defaultNow) sql += ` DEFAULT CURRENT_TIMESTAMP`;
+    if (FieldConfig.SQlType !== "STRUCT" && FieldConfig.SQlType !== "LIST" && FieldConfig.default !== false && FieldConfig.default !== void 0) {
+      if (typeof FieldConfig.default !== "function") {
+        sql += ` DEFAULT ${typeof FieldConfig.default === "string" ? `'${FieldConfig.default}'` : JSON.stringify(FieldConfig.default)}`;
+      }
+    }
+    if ((FieldConfig.SQlType == "STRUCT" || FieldConfig.SQlType == "LIST") && FieldConfig.default !== false && FieldConfig.default !== void 0) {
+      sql += ` DEFAULT ${JSON.stringify(FieldConfig.default).split('"').join("'")}`;
+    }
+    return {
+      sql: sql.trim(),
+      // @ts-ignore
+      ref: FieldConfig.reference
+    };
+  }
+  static BuildTable(name, t) {
+    const fieldDefs = Object.entries(t).filter(([key]) => key !== "__tableName").map(([fieldName, builder]) => {
+      const Result = this.BuildField(fieldName, builder);
+      return Result.sql;
+    });
+    return `CREATE TABLE IF NOT EXISTS ${name} (
+  ${fieldDefs.join(
+      ",\n  "
+    )}
+);`;
+  }
+};
+
+// src/fluent.ts
+function createFluentBuilder(onBuild) {
+  const data = {};
+  const handler = {
+    get(target, prop) {
+      if (prop === "then") {
+        return (resolve, reject) => {
+          const result = onBuild ? onBuild(target) : target;
+          Promise.resolve(result).then(resolve, reject);
+        };
+      }
+      return (...args) => {
+        if (args.length === 0) {
+          target[prop] = true;
+        } else if (args.length === 1) {
+          target[prop] = args[0];
+        } else {
+          target[prop] = args;
+        }
+        return new Proxy(target, handler);
+      };
+    }
+  };
+  return new Proxy(data, handler);
+}
+
+// src/Qfluent.ts
+var createProxyHandler = (table, config, isSingleResult) => {
+  return {
+    get(target, prop) {
+      if (prop === "then") {
+        return async (resolve, reject) => {
+          const tableAny = table;
+          try {
+            const { sql } = tableAny.BuildSelect(tableAny["Name"], config);
+            const rawResult = await (await tableAny.Connection.run(sql)).getRowObjects();
+            const formatted = tableAny.FormatOut(rawResult);
+            if (isSingleResult) {
+              const val = formatted.length > 0 ? formatted[0] : void 0;
+              resolve(val);
+            } else {
+              resolve(formatted);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        };
+      }
+      if (prop === "extend") {
+        return (extTable) => {
+          config.extend = config.extend || [];
+          if (!config.extend.includes(extTable)) {
+            config.extend.push(extTable);
+          }
+          return new Proxy(
+            target,
+            createProxyHandler(table, config, isSingleResult)
+          );
+        };
+      }
+      return (...args) => {
+        if (args.length === 1) {
+          config[prop] = args[0];
+        } else if (args.length > 1) {
+          config[prop] = args;
+        } else {
+          config[prop] = true;
+        }
+        return new Proxy(
+          target,
+          createProxyHandler(table, config, isSingleResult)
+        );
+      };
+    }
+  };
+};
+function createQueryBuilder(table, initialConfig = {}) {
+  const dummyState = {};
+  return new Proxy(
+    dummyState,
+    createProxyHandler(table, initialConfig, false)
+  );
+}
+function createQueryBuilderOne(table, initialConfig = {}) {
+  const config = { ...initialConfig, limit: 1 };
+  const dummyState = {};
+  return new Proxy(
+    dummyState,
+    createProxyHandler(table, config, true)
+  );
+}
+
+// src/table.ts
+var ConditionBuilderImpl = class _ConditionBuilderImpl {
+  constructor(node) {
+    this.node = node;
+  }
+  createOp(op, value) {
+    return new _ConditionBuilderImpl({
+      type: "condition",
+      op,
+      value
+    });
+  }
+  eq(value) {
+    return this.createOp("eq", value);
+  }
+  ne(value) {
+    return this.createOp("ne", value);
+  }
+  gt(value) {
+    return this.createOp("gt", value);
+  }
+  gte(value) {
+    return this.createOp("gte", value);
+  }
+  lt(value) {
+    return this.createOp("lt", value);
+  }
+  lte(value) {
+    return this.createOp("lte", value);
+  }
+  in(value) {
+    return this.createOp("in", value);
+  }
+  notIn(value) {
+    return this.createOp("notIn", value);
+  }
+  between(value) {
+    return this.createOp("between", value);
+  }
+  notBetween(value) {
+    return this.createOp("notBetween", value);
+  }
+  is(value) {
+    return this.createOp("is", value);
+  }
+  isNot(value) {
+    return this.createOp("isNot", value);
+  }
+  like(value) {
+    return this.createOp("like", value);
+  }
+  notLike(value) {
+    return this.createOp("notLike", value);
+  }
+  startsWith(value) {
+    return this.createOp("startsWith", value);
+  }
+  endsWith(value) {
+    return this.createOp("endsWith", value);
+  }
+  contains(value) {
+    return this.createOp("contains", value);
+  }
+  regexp(value) {
+    return this.createOp("regexp", value);
+  }
+  notRegexp(value) {
+    return this.createOp("notRegexp", value);
+  }
+  and(other) {
+    return new _ConditionBuilderImpl({
+      type: "and",
+      left: this.node,
+      right: other.__getNode()
+    });
+  }
+  or(other) {
+    return new _ConditionBuilderImpl({
+      type: "or",
+      left: this.node,
+      right: other.__getNode()
+    });
+  }
+  __getNode() {
+    return this.node;
+  }
+};
+function cond() {
+  return new ConditionBuilderImpl({ type: "condition" });
+}
+var eq = (value) => cond().eq(value);
+var ne = (value) => cond().ne(value);
+var gt = (value) => cond().gt(value);
+var gte = (value) => cond().gte(value);
+var lt = (value) => cond().lt(value);
+var lte = (value) => cond().lte(value);
+var inOp = (value) => cond().in(value);
+var notIn = (value) => cond().notIn(value);
+var between = (value) => cond().between(value);
+var notBetween = (value) => cond().notBetween(value);
+var is = (value) => cond().is(value);
+var isNot = (value) => cond().isNot(value);
+var like = (value) => cond().like(value);
+var notLike = (value) => cond().notLike(value);
+var startsWith = (value) => cond().startsWith(value);
+var endsWith = (value) => cond().endsWith(value);
+var contains = (value) => cond().contains(value);
+var regexp = (value) => cond().regexp(value);
+var notRegexp = (value) => cond().notRegexp(value);
+var escape = (val) => {
+  if (val === null || val === void 0) 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);
+};
+var SQL_GENERATORS = {
+  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.map(escape).join(", ")})`,
+  notIn: (c, v) => `${c} NOT IN (${v.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)})`
+};
+var OptimaTable = class _OptimaTable {
+  constructor(name, Columns, Connection) {
+    this.listeners = /* @__PURE__ */ new Set();
+    // --- SHARED: Where Clause Builder ---
+    this.BuildWhereClause = (where) => {
+      if (!where) return "";
+      const conditions = [];
+      const nodeToSQL = (node, colName) => {
+        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 "";
+      };
+      const processLevel = (currentWhere, pathPrefix) => {
+        for (const key of Object.keys(currentWhere)) {
+          const val = currentWhere[key];
+          const colName = pathPrefix ? `${pathPrefix}.${key}` : key;
+          if (val === void 0) continue;
+          if (val && typeof val === "object" && "__getNode" in val && typeof val.__getNode === "function") {
+            const node = val.__getNode();
+            const sql = nodeToSQL(node, colName);
+            if (sql) conditions.push(sql);
+          } else if (val && typeof val === "object" && !Array.isArray(val) && !(val instanceof Date)) {
+            processLevel(val, colName);
+          } else {
+            conditions.push(SQL_GENERATORS.eq(colName, val));
+          }
+        }
+      };
+      processLevel(where, "");
+      if (conditions.length > 0) {
+        return ` WHERE ${conditions.join(" AND ")}`;
+      }
+      return "";
+    };
+    this.BuildSelect = (TableName, options) => {
+      const { limit, orderBy, offset, groupBy, where, extend } = options;
+      let selectColumns = `${TableName}.*`;
+      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 !== void 0 && limit !== null) query += ` LIMIT ${limit}`;
+      if (offset !== void 0 && offset !== null) query += ` OFFSET ${offset}`;
+      return { sql: query, args: [] };
+    };
+    this.BuildInsert = (TableName, Records, isReturning) => {
+      const columnKeys = Object.keys(this.Columns);
+      const columnsHeader = `(${columnKeys.join(", ")})`;
+      const valuesBlock = Records.map((r) => {
+        const orderedValues = columnKeys.map((key) => {
+          let v = r[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 
+${valuesBlock}${isReturning ? "\nRETURNING *" : ""};`;
+      return { sql };
+    };
+    this.BuildUpdate = (TableName, changes, options) => {
+      const { where, returning } = options;
+      const setClauses = [];
+      for (const [key, value] of Object.entries(changes)) {
+        if (value !== void 0) {
+          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: [] };
+    };
+    this.BuildDelete = (TableName, options) => {
+      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
+    this.parseRecursive = (value) => {
+      if (value === null || value === void 0) {
+        return value;
+      }
+      if (value instanceof Date) {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => this.parseRecursive(item));
+      }
+      if (typeof value === "object") {
+        if (value.entries !== void 0) {
+          return this.parseRecursive(value.entries);
+        }
+        if (value.items !== void 0) {
+          return this.parseRecursive(value.items);
+        }
+        const parsedObj = {};
+        for (const [k, v] of Object.entries(value)) {
+          parsedObj[k] = this.parseRecursive(v);
+        }
+        return parsedObj;
+      }
+      return value;
+    };
+    this.FormatOut = (data) => {
+      return data.map((row) => {
+        const formatted = {};
+        for (const [key, value] of Object.entries(row)) {
+          if (key.startsWith("$") && value === null) {
+            formatted[key] = [];
+            continue;
+          }
+          formatted[key] = this.parseRecursive(value);
+        }
+        return formatted;
+      });
+    };
+    this.Name = name;
+    const filteredCols = { ...Columns };
+    if ("__tableName" in filteredCols) {
+      delete filteredCols["__tableName"];
+    }
+    this.Columns = filteredCols;
+    this.Connection = Connection;
+  }
+  notifyChange(change) {
+    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) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  async InitTable() {
+    const SQL = SQLBuilder.BuildTable(this.Name, this.Columns);
+    await this.Connection.run(SQL);
+  }
+  static async create(name, Columns, Connection) {
+    const table = new _OptimaTable(name, Columns, Connection);
+    await table.InitTable();
+    return table;
+  }
+  // ---------------------------------------------------------
+  // UPDATED: Get() now uses the Fluent Factory
+  // ---------------------------------------------------------
+  Get() {
+    return createQueryBuilder(this);
+  }
+  // ---------------------------------------------------------
+  // UPDATED: GetOne() now uses the Fluent Factory
+  // ---------------------------------------------------------
+  GetOne() {
+    return createQueryBuilderOne(this);
+  }
+  Exist() {
+    return createFluentBuilder(async (data) => {
+      const whereClause = this.BuildWhereClause(data.where);
+      const sql = `SELECT 1 FROM ${this.Name}${whereClause} LIMIT 1`;
+      const Result = 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) {
+    return createFluentBuilder(async (data) => {
+      this.Validate(record);
+      record = this.Transform(record);
+      const { sql } = this.BuildInsert(this.Name, [record], data.returning);
+      const Result = await (await this.Connection.run(sql)).getRowObjects();
+      const Res = this.FormatOut(Result);
+      if (Res.length != 0) {
+        if (data.returning) {
+          this.notifyChange({ event: "Add", data: Res, time: /* @__PURE__ */ new Date() });
+        } else {
+          this.notifyChange({
+            event: "Add",
+            data: await this.GetOne().where(record),
+            time: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      return Res;
+    });
+  }
+  /**
+   * Add multiple records.
+   * Returns: TSchema[]
+   */
+  AddMany(records) {
+    return createFluentBuilder(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 = await (await this.Connection.run(sql)).getRowObjects();
+      const Res = this.FormatOut(Result);
+      if (Res.length != 0) {
+        if (data.returning) {
+          this.notifyChange({ event: "AddMany", data: Res, time: /* @__PURE__ */ new Date() });
+        } else {
+          const Added = transformedRecords;
+          const addedPromises = Added.map(
+            async (record) => await this.GetOne().where(record)
+          );
+          const addedRecords = await Promise.all(addedPromises);
+          this.notifyChange({
+            event: "Add",
+            data: addedRecords,
+            time: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      return Res;
+    });
+  }
+  /**
+   * Update records.
+   * Returns: TSchema[]
+   */
+  Update(record) {
+    return createFluentBuilder(async (data) => {
+      this.Validate(record);
+      record = this.Transform(record);
+      const PotentialyUpdated = await this.Get().where(record);
+      if (PotentialyUpdated.length == 0) return [];
+      else {
+        const { sql } = this.BuildUpdate(this.Name, record, data);
+        const Result = await (await this.Connection.run(sql)).getRowObjects();
+        if (Result.length != 0) {
+          if (data.returning) {
+            this.notifyChange({ event: "AddMany", data: Result, time: /* @__PURE__ */ new Date() });
+          } else {
+            const Updated = PotentialyUpdated;
+            const UpdatedPromises = Updated.map(
+              async (record2) => await this.GetOne().where(record2)
+            );
+            const UpdatedRecords = await Promise.all(UpdatedPromises);
+            this.notifyChange({
+              event: "Add",
+              data: UpdatedRecords,
+              time: /* @__PURE__ */ new Date()
+            });
+          }
+        }
+        return data.returning ? this.FormatOut(Result) : Result;
+      }
+    });
+  }
+  /**
+   * Delete records.
+   * Returns: TSchema | undefined (The code logic returns index [0], implies single delete or returning first)
+   */
+  Delete() {
+    return createFluentBuilder(async (data) => {
+      const PotentiallyDeleted = await this.Get().where(data.where);
+      if (PotentiallyDeleted.length == 0) return void 0;
+      const { sql } = this.BuildDelete(this.Name, { ...data });
+      const Result = await (await this.Connection.run(sql)).getRowObjects();
+      if (Result.length != 0) {
+        if (data.returning) {
+          this.notifyChange({ event: "DeleteMany", data: Result, time: /* @__PURE__ */ new Date() });
+        } else {
+          const DeletedRecords = PotentiallyDeleted;
+          this.notifyChange({
+            event: "Delete",
+            data: DeletedRecords,
+            time: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      const formatted = this.FormatOut(Result);
+      return formatted[0];
+    });
+  }
+  Count() {
+    return createFluentBuilder(
+      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();
+        return Number(result[0].count);
+      }
+    );
+  }
+  /**
+   * Auto-resolves relationships based on schema 'reference'
+   */
+  ResolveJoin(targetTable) {
+    const myName = this.Name;
+    const targetName = targetTable.Name;
+    const getRef = (builder) => {
+      const refConf = builder.config.reference;
+      if (typeof refConf === "string") return { ref: refConf, isMany: false };
+      if (refConf && typeof refConf === "object") return refConf;
+      return null;
+    };
+    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) {
+          return {
+            sql: `${myName}.${colName} = ${targetName}.${refCol}`,
+            isMany: config.isMany
+          };
+        }
+      }
+    }
+    console.warn(
+      `Could not resolve relationship between ${myName} and ${targetName}`
+    );
+    return null;
+  }
+  // -- Validator --
+  Validate(data) {
+    const Cols = Object.fromEntries(
+      //@ts-ignore
+      Object.entries(this.Columns).map(([col, val]) => [col, val.config])
+    );
+    for (const [field, config] of Object.entries(Cols)) {
+      if (data[field] === void 0) 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 --
+  Transform(data) {
+    const Cols = Object.fromEntries(
+      //@ts-ignore
+      Object.entries(this.Columns).map(([col, val]) => [col, val.config])
+    );
+    const transformed = { ...data };
+    for (const [field, config] of Object.entries(Cols)) {
+      if (transformed[field] === void 0) continue;
+      if ("transform" in config && typeof config.transform === "function") {
+        const fn = config.transform;
+        transformed[field] = fn(transformed[field]);
+      }
+    }
+    return transformed;
+  }
+};
+
+// src/database.ts
+var OptimaDB = class _OptimaDB {
+  constructor(instance, connection, tables) {
+    this.instance = instance;
+    this.connection = connection;
+    this.Tables = tables;
+  }
+  /**
+   * Initializes the database, connects, detects schema changes, 
+   * runs migrations, and returns the DB instance.
+   */
+  static async Open(name = ":memory:", schema, options) {
+    const instance = await DuckDBInstance.create(name);
+    const connection = await instance.connect();
+    if (options?.MemoryLimit) {
+      await connection.run(`SET memory_limit = '${options.MemoryLimit}';`);
+    }
+    if (options?.ThreadCount) {
+      await connection.run(`SET threads = ${options.ThreadCount};`);
+    }
+    const existingTables = await (await connection.run(`SELECT * from duckdb_tables`)).getRowObjects();
+    const cleanSchema = SchemaMigrator.transformSchema(schema);
+    const migrationSQL = SchemaMigrator.generateSQL(existingTables, cleanSchema);
+    if (migrationSQL.length > 0) {
+      console.log(`[OptimaDB] Applying ${migrationSQL.length} migrations...`);
+      await connection.run("BEGIN TRANSACTION;");
+      try {
+        for (const sql of migrationSQL) {
+          await connection.run(sql);
+        }
+        await connection.run("COMMIT;");
+      } catch (err) {
+        await connection.run("ROLLBACK;");
+        console.error("[OptimaDB] Migration failed, rolling back.", err);
+        throw err;
+      }
+    }
+    const tables = {};
+    for (const key of Object.keys(schema)) {
+      tables[key] = await OptimaTable.create(
+        key,
+        schema[key],
+        connection
+      );
+    }
+    return new _OptimaDB(instance, connection, tables);
+  }
+  /**
+   * Executes a raw SQL query and returns rows as objects.
+   */
+  async execute(sql) {
+    return (await this.connection.run(sql)).getRowObjects();
+  }
+  async getTables() {
+    const result = await this.execute("PRAGMA show_tables;");
+    return result.map((t) => t.name);
+  }
+  async getDiskSize() {
+    const result = await this.execute("PRAGMA database_size;");
+    return result[0];
+  }
+  /**
+   * Runs a function within a transaction. 
+   * Re-throws error after rollback so caller handles logic failure.
+   */
+  async transaction(fn) {
+    await this.connection.run("BEGIN TRANSACTION;");
+    try {
+      const result = await fn();
+      await this.connection.run("COMMIT;");
+      return result;
+    } catch (e) {
+      await this.connection.run("ROLLBACK;");
+      throw e;
+    }
+  }
+};
+var SchemaMigrator = class {
+  /**
+   * Transforms the complex Module/ColumnImpl schema into a simple config object.
+   */
+  static transformSchema(schemaObject) {
+    const cleanSchema = {};
+    for (const [tableName, tableDef] of Object.entries(schemaObject)) {
+      if (typeof tableDef !== "object" || tableDef === null) continue;
+      const realTableName = tableDef.__tableName || tableName;
+      cleanSchema[realTableName] = {};
+      for (const [colName, colImpl] of Object.entries(tableDef)) {
+        if (colName.startsWith("__")) continue;
+        if (colImpl?.config) {
+          const config = { ...colImpl.config };
+          if (config.SQlType === "STRUCT" && config.STRUCTType) {
+            config.SQlType = config.STRUCTType;
+          }
+          cleanSchema[realTableName][colName] = config;
+        }
+      }
+    }
+    return cleanSchema;
+  }
+  /**
+   * Generates SQL statements to migrate DB from Current -> Desired state.
+   */
+  static generateSQL(existingTablesRaw, desiredSchema) {
+    const currentSchema = this.parseDuckDBTableSQL(existingTablesRaw);
+    const steps = [];
+    for (const [tableName, fields] of Object.entries(desiredSchema)) {
+      if (!currentSchema[tableName]) {
+        const fieldDefs = Object.entries(fields).map(([colName, config]) => {
+          let def = `"${colName}" ${config.SQlType}`;
+          if (config.primaryKey) def += " PRIMARY KEY";
+          if (config.notnull) def += " NOT NULL";
+          return def;
+        });
+        steps.push(`CREATE TABLE ${tableName} (${fieldDefs.join(", ")});`);
+        continue;
+      }
+      const currentTableCols = currentSchema[tableName];
+      for (const [colName, config] of Object.entries(fields)) {
+        if (!currentTableCols[colName]) {
+          let def = `${config.SQlType}`;
+          if (config.notnull) {
+            def += ` DEFAULT ${this.getDefaultValueForType(config.SQlType)}`;
+          }
+          steps.push(`ALTER TABLE ${tableName} ADD COLUMN "${colName}" ${def};`);
+          if (config.notnull) {
+            steps.push(`ALTER TABLE ${tableName} ALTER "${colName}" SET NOT NULL;`);
+          }
+          continue;
+        }
+        const currentCol = currentTableCols[colName];
+        const normCurrentType = currentCol.type.replace(/\s+/g, "").toUpperCase();
+        const normNewType = config.SQlType.replace(/\s+/g, "").toUpperCase();
+        if (normCurrentType !== normNewType && !normNewType.startsWith("STRUCT")) {
+          steps.push(`ALTER TABLE ${tableName} ALTER "${colName}" TYPE ${config.SQlType};`);
+        }
+        const desiredNotNull = !!config.notnull;
+        if (desiredNotNull !== currentCol.isNotNull) {
+          if (desiredNotNull) {
+            steps.push(`ALTER TABLE ${tableName} ALTER "${colName}" SET NOT NULL;`);
+          } else {
+            steps.push(`ALTER TABLE ${tableName} ALTER "${colName}" DROP NOT NULL;`);
+          }
+        }
+      }
+    }
+    return steps;
+  }
+  /**
+   * Parses raw "CREATE TABLE" SQL from DuckDB into a usable map.
+   */
+  static parseDuckDBTableSQL(existingTables) {
+    const schemaMap = {};
+    existingTables.forEach((table) => {
+      const match = table.sql.match(/CREATE TABLE "?\w+"?\s*\((.*)\);/s);
+      if (!match) return;
+      const columnBody = match[1];
+      const columns = {};
+      let depth = 0;
+      let currentChunk = "";
+      for (let i = 0; i < columnBody.length; i++) {
+        const char = columnBody[i];
+        if (char === "(") depth++;
+        if (char === ")") depth--;
+        if (char === "," && depth === 0) {
+          this.processColumnLine(currentChunk, columns);
+          currentChunk = "";
+        } else {
+          currentChunk += char;
+        }
+      }
+      if (currentChunk.trim()) this.processColumnLine(currentChunk, columns);
+      schemaMap[table.table_name] = columns;
+    });
+    return schemaMap;
+  }
+  static processColumnLine(line, columnMap) {
+    const parts = line.trim().match(/^("?[\w]+"?)\s+(.*)$/);
+    if (!parts) return;
+    const name = parts[1]?.replace(/"/g, "");
+    const definition = parts[2];
+    const upDef = definition?.toUpperCase();
+    let type = definition?.split(" ")[0];
+    if (upDef?.startsWith("STRUCT")) {
+      type = definition;
+    }
+    if (name !== void 0) {
+      columnMap[name] = {
+        type,
+        isNotNull: upDef?.includes("NOT NULL") ?? false,
+        isPrimaryKey: upDef?.includes("PRIMARY KEY") ?? false
+      };
+    }
+  }
+  /**
+   * Returns a safe default value for a given SQL type.
+   * Required when adding NOT NULL columns to existing tables.
+   */
+  static getDefaultValueForType(type) {
+    const t = type.toUpperCase();
+    if (t.includes("INT") || t.includes("FLOAT") || t.includes("DECIMAL") || t.includes("DOUBLE")) return "0";
+    if (t.includes("BOOL")) return "FALSE";
+    if (t.includes("STRUCT") || t.includes("MAP") || t.includes("LIST")) return "NULL";
+    return "''";
+  }
+};
+
+// src/index.ts
+__reExport(index_exports, schema_exports);
+export {
+  Array2 as Array,
+  BigInt,
+  Boolean,
+  Bytes,
+  Color,
+  DateType,
+  Email,
+  Enum,
+  Float,
+  GeoArea,
+  GeoPoint,
+  Int,
+  Json,
+  OptimaDB,
+  Password,
+  SQLBuilder,
+  Slug,
+  Table,
+  Text,
+  Timestamp,
+  Uuid,
+  between,
+  cond,
+  contains,
+  endsWith,
+  eq,
+  gt,
+  gte,
+  inOp,
+  is,
+  isNot,
+  like,
+  lt,
+  lte,
+  ne,
+  notBetween,
+  notIn,
+  notLike,
+  notRegexp,
+  refHelpers,
+  regexp,
+  startsWith
+};