@inflector/optima 1.0.1 → 1.0.2

package/dist/table.js

@@ -1,617 +0,0 @@
-import { SQLBuilder, } from "./schema";
-import { createFluentBuilder } from "./fluent";
-import { createQueryBuilder, createQueryBuilderOne, } 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",
-];
-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;
-    }
-}
-export function cond() {
-    return new ConditionBuilderImpl({ type: "condition" });
-}
-// Exports for standalone operators
-export const eq = (value) => cond().eq(value);
-export const ne = (value) => cond().ne(value);
-export const gt = (value) => cond().gt(value);
-export const gte = (value) => cond().gte(value);
-export const lt = (value) => cond().lt(value);
-export const lte = (value) => cond().lte(value);
-export const inOp = (value) => cond().in(value);
-export const notIn = (value) => cond().notIn(value);
-export const between = (value) => cond().between(value);
-export const notBetween = (value) => cond().notBetween(value);
-export const is = (value) => cond().is(value);
-export const isNot = (value) => cond().isNot(value);
-export const like = (value) => cond().like(value);
-export const notLike = (value) => cond().notLike(value);
-export const startsWith = (value) => cond().startsWith(value);
-export const endsWith = (value) => cond().endsWith(value);
-export const contains = (value) => cond().contains(value);
-export const regexp = (value) => cond().regexp(value);
-export const notRegexp = (value) => cond().notRegexp(value);
-// ---------------------------------------------------------
-// 4. SQL GENERATION UTILITIES (Unchanged)
-// ---------------------------------------------------------
-const escape = (val) => {
-    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 = {
-    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)})`,
-};
-export class OptimaTable {
-    constructor(name, Columns, Connection) {
-        this.listeners = new Set();
-        // --- SHARED: Where Clause Builder ---
-        this.BuildWhereClause = (where) => {
-            if (!where)
-                return "";
-            const conditions = [];
-            // Helper to generate SQL for specific operators
-            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 "";
-            };
-            // Recursive function to handle nested objects (Structs)
-            const processLevel = (currentWhere, pathPrefix) => {
-                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.__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 "";
-        };
-        this.BuildSelect = (TableName, options) => {
-            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: [] };
-        };
-        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 \n${valuesBlock}${isReturning ? "\nRETURNING *" : ""};`;
-            return { sql: sql };
-        };
-        this.BuildUpdate = (TableName, changes, options) => {
-            const { where, returning } = options;
-            const setClauses = [];
-            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: [] };
-        };
-        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) => {
-            // 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 = {};
-                for (const [k, v] of Object.entries(value)) {
-                    parsedObj[k] = this.parseRecursive(v);
-                }
-                return parsedObj;
-            }
-            // 5. Primitives (string, number, boolean)
-            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;
-                    }
-                    // 2. Recursively parse everything else
-                    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: new Date() });
-                }
-                else {
-                    this.notifyChange({
-                        event: "Add",
-                        data: await this.GetOne().where(record),
-                        time: 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: 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));
-                    const addedRecords = await Promise.all(addedPromises);
-                    this.notifyChange({
-                        event: "Add",
-                        data: addedRecords,
-                        time: 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: new Date() });
-                    }
-                    else {
-                        const Updated = PotentialyUpdated;
-                        const UpdatedPromises = Updated.map(async (record) => await this.GetOne().where(record));
-                        const UpdatedRecords = await Promise.all(UpdatedPromises);
-                        this.notifyChange({
-                            event: "Add",
-                            data: UpdatedRecords,
-                            time: 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) => {
-            // Find what would be potentially deleted using the where clause
-            const PotentiallyDeleted = await this.Get().where(data.where);
-            if (PotentiallyDeleted.length == 0)
-                return undefined;
-            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: new Date() });
-                }
-                else {
-                    const DeletedRecords = PotentiallyDeleted;
-                    this.notifyChange({
-                        event: "Delete",
-                        data: DeletedRecords,
-                        time: 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();
-            // @ts-ignore
-            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) => {
-            // @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 --
-    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)) {
-            // 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 --
-    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)) {
-            // 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;
-    }
-}