ts-prorm-orm 1.1.0

package/dist/query-builders/functions/window.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * Typed window-function builder API.
+ *
+ * Provides a fluent, chainable builder for SQL window functions
+ * (`OVER (PARTITION BY ... ORDER BY ... ROWS/RANGE BETWEEN ...)`) so callers
+ * never need to hand-write raw SQL strings for `ROW_NUMBER()`, `RANK()`,
+ * `LAG()`, `LEAD()`, and friends.
+ *
+ * This module is intentionally self-contained: it does not add any new
+ * dispatch branches to the shared SQL compiler. Every builder resolves
+ * directly to a final SQL fragment string, which is then wrapped with the
+ * existing `literalExpr()`/`literal()` helpers from `src/operators.ts` so it
+ * slots into `attributes: [...]` arrays exactly the way `fn()`/`col()`/
+ * `cast()` do today (see `attributeToSql()` / `processAttribute()` in
+ * `src/query-builders/sql-compiler.ts`, which both already know how to
+ * render `{ __type: 'literal', sql }` and `[expr, alias]` tuples).
+ *
+ * @example
+ * ```typescript
+ * import { rowNumber, rank, lag, sumOver } from './query-builders/functions/window';
+ * import { col } from '../../operators';
+ *
+ * User.findAll({
+ *   attributes: [
+ *     'department',
+ *     'salary',
+ *     rowNumber().partitionBy('department').orderBy('salary', 'DESC').as('rn'),
+ *     rank().partitionBy(col('department')).orderBy(col('salary'), 'DESC').as('rnk'),
+ *     lag(col('salary'), 1).partitionBy('department').orderBy('hireDate').as('prevSalary'),
+ *     sumOver(col('salary'))
+ *       .partitionBy('department')
+ *       .orderBy('hireDate')
+ *       .rows({ start: 'unboundedPreceding', end: 'currentRow' })
+ *       .as('runningTotal'),
+ *   ],
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowFunctionBuilder = exports.NullsOrder = void 0;
+exports.rowNumber = rowNumber;
+exports.rank = rank;
+exports.denseRank = denseRank;
+exports.percentRank = percentRank;
+exports.cumeDist = cumeDist;
+exports.ntile = ntile;
+exports.lag = lag;
+exports.lead = lead;
+exports.firstValue = firstValue;
+exports.lastValue = lastValue;
+exports.nthValue = nthValue;
+exports.sumOver = sumOver;
+exports.avgOver = avgOver;
+exports.countOver = countOver;
+exports.minOver = minOver;
+exports.maxOver = maxOver;
+exports.windowFn = windowFn;
+const operators_1 = require("../../operators");
+/**
+ * `NULLS FIRST` / `NULLS LAST` modifier, supported by most (not all) dialects.
+ *
+ * Companion enum {@link NullsOrder} is available for the `'FIRST' | 'LAST'`
+ * string-literal union below; raw string literals continue to work unchanged.
+ *
+ * @example
+ * ```typescript
+ * // Using raw string literals (still supported)
+ * rowNumber().orderBy('salary', 'DESC', 'LAST')
+ *
+ * // Using the NullsOrder enum
+ * import { NullsOrder } from './query-builders/functions/window';
+ * rowNumber().orderBy('salary', 'DESC', NullsOrder.LAST)
+ * ```
+ */
+var NullsOrder;
+(function (NullsOrder) {
+    NullsOrder["FIRST"] = "FIRST";
+    NullsOrder["LAST"] = "LAST";
+})(NullsOrder || (exports.NullsOrder = NullsOrder = {}));
+function escapeIdentifier(name) {
+    // Support dotted "table.column" references, same convention as col().
+    if (name.includes('.')) {
+        return name
+            .split('.')
+            .map((part) => `"${part.replace(/"/g, '""')}"`)
+            .join('.');
+    }
+    return `"${name.replace(/"/g, '""')}"`;
+}
+/**
+ * Flatten a window-function argument (string, ColExpression, FnExpression,
+ * LiteralExpression, number, null) into a raw SQL fragment string.
+ */
+function toSqlFragment(arg) {
+    if (arg === null)
+        return 'NULL';
+    if (arg === undefined)
+        return 'NULL';
+    if (typeof arg === 'number') {
+        return String(arg);
+    }
+    if (typeof arg === 'string') {
+        return escapeIdentifier(arg);
+    }
+    if ((0, operators_1.isFnExpression)(arg)) {
+        const args = arg.args.map((a) => toSqlFragment(a)).join(', ');
+        return `${arg.fn}(${args})`;
+    }
+    if ((0, operators_1.isColExpression)(arg)) {
+        return escapeIdentifier(arg.col);
+    }
+    if ((0, operators_1.isLiteralExpression)(arg)) {
+        // Handles both { __type: 'literal', sql } and { $literal: sql } shapes.
+        return arg.sql ?? arg.$literal;
+    }
+    // Fallback: stringify.
+    return String(arg);
+}
+function frameBoundaryToSql(boundary) {
+    if (boundary === 'unboundedPreceding')
+        return 'UNBOUNDED PRECEDING';
+    if (boundary === 'unboundedFollowing')
+        return 'UNBOUNDED FOLLOWING';
+    if (boundary === 'currentRow')
+        return 'CURRENT ROW';
+    if (typeof boundary === 'object' && boundary !== null) {
+        if ('preceding' in boundary)
+            return `${boundary.preceding} PRECEDING`;
+        if ('following' in boundary)
+            return `${boundary.following} FOLLOWING`;
+    }
+    throw new Error(`Invalid window frame boundary: ${JSON.stringify(boundary)}`);
+}
+/**
+ * A chainable builder that accumulates PARTITION BY / ORDER BY / frame
+ * clauses for a single window function call and renders the final
+ * `FN(args) OVER (...)` SQL fragment.
+ */
+class WindowFunctionBuilder {
+    constructor(fnName, fnArgs = []) {
+        this.partitions = [];
+        this.orders = [];
+        this.fnName = fnName;
+        this.fnArgs = fnArgs;
+    }
+    /**
+     * Set (or narrow) the target dialect. Only matters for the rare cases
+     * where OVER-clause syntax genuinely diverges (all listed dialects use the
+     * same ANSI-standard OVER syntax today, so this is mostly a documented
+     * escape hatch for future dialect-specific tweaks).
+     */
+    forDialect(dialect) {
+        this.dialect = dialect;
+        return this;
+    }
+    /** Add one or more PARTITION BY columns/expressions. Repeatable/additive. */
+    partitionBy(...cols) {
+        this.partitions.push(...cols);
+        return this;
+    }
+    /**
+     * Add an ORDER BY entry to the window definition. Call multiple times to
+     * order by multiple columns; each call appends one entry.
+     */
+    orderBy(expr, direction, nulls) {
+        this.orders.push({ expr, direction, nulls });
+        return this;
+    }
+    /** Set a ROWS frame clause, e.g. `ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW`. */
+    rows(frame) {
+        this.frameMode = 'ROWS';
+        this.frame = frame;
+        return this;
+    }
+    /** Set a RANGE frame clause, e.g. `RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW`. */
+    range(frame) {
+        this.frameMode = 'RANGE';
+        this.frame = frame;
+        return this;
+    }
+    /** Render the `FN(args) OVER (...)` SQL fragment (no alias). */
+    toSQL() {
+        const argsSql = this.fnArgs.map((a) => toSqlFragment(a)).join(', ');
+        const overParts = [];
+        if (this.partitions.length > 0) {
+            overParts.push(`PARTITION BY ${this.partitions.map((p) => toSqlFragment(p)).join(', ')}`);
+        }
+        if (this.orders.length > 0) {
+            const orderSql = this.orders
+                .map((o) => {
+                let part = toSqlFragment(o.expr);
+                if (o.direction)
+                    part += ` ${o.direction}`;
+                if (o.nulls)
+                    part += ` NULLS ${o.nulls}`;
+                return part;
+            })
+                .join(', ');
+            overParts.push(`ORDER BY ${orderSql}`);
+        }
+        if (this.frameMode && this.frame) {
+            const start = frameBoundaryToSql(this.frame.start);
+            if (this.frame.end) {
+                const end = frameBoundaryToSql(this.frame.end);
+                overParts.push(`${this.frameMode} BETWEEN ${start} AND ${end}`);
+            }
+            else {
+                overParts.push(`${this.frameMode} ${start}`);
+            }
+        }
+        const overClause = overParts.length > 0 ? `OVER (${overParts.join(' ')})` : 'OVER ()';
+        return `${this.fnName}(${argsSql}) ${overClause}`;
+    }
+    /**
+     * Terminal call: returns an `[expr, alias]` tuple compatible with the
+     * existing `attributes: [...]` pattern (see `attributeToSql()` /
+     * `attributeToSqlWithAlias()` in `sql-compiler.ts`, both of which already
+     * know how to render `[LiteralExpression, alias]` tuples without any core
+     * changes).
+     */
+    as(alias) {
+        return [(0, operators_1.literalExpr)(this.toSQL()), alias];
+    }
+    /**
+     * Allow the builder to be used directly wherever a raw SQL literal is
+     * expected (e.g. passed straight into `literal()`-consuming positions)
+     * without requiring `.as(...)`.
+     */
+    toLiteral() {
+        return (0, operators_1.literalExpr)(this.toSQL());
+    }
+}
+exports.WindowFunctionBuilder = WindowFunctionBuilder;
+// ---------------------------------------------------------------------------
+// Ranking functions
+// ---------------------------------------------------------------------------
+/** `ROW_NUMBER() OVER (...)` */
+function rowNumber() {
+    return new WindowFunctionBuilder('ROW_NUMBER');
+}
+/** `RANK() OVER (...)` */
+function rank() {
+    return new WindowFunctionBuilder('RANK');
+}
+/** `DENSE_RANK() OVER (...)` */
+function denseRank() {
+    return new WindowFunctionBuilder('DENSE_RANK');
+}
+/** `PERCENT_RANK() OVER (...)` */
+function percentRank() {
+    return new WindowFunctionBuilder('PERCENT_RANK');
+}
+/** `CUME_DIST() OVER (...)` */
+function cumeDist() {
+    return new WindowFunctionBuilder('CUME_DIST');
+}
+/** `NTILE(buckets) OVER (...)` */
+function ntile(buckets) {
+    return new WindowFunctionBuilder('NTILE', [buckets]);
+}
+// ---------------------------------------------------------------------------
+// Value / offset functions
+// ---------------------------------------------------------------------------
+/** `LAG(expr[, offset[, default]]) OVER (...)` */
+function lag(expr, offset, defaultValue) {
+    const args = [expr];
+    if (offset !== undefined)
+        args.push(offset);
+    if (defaultValue !== undefined)
+        args.push(defaultValue);
+    return new WindowFunctionBuilder('LAG', args);
+}
+/** `LEAD(expr[, offset[, default]]) OVER (...)` */
+function lead(expr, offset, defaultValue) {
+    const args = [expr];
+    if (offset !== undefined)
+        args.push(offset);
+    if (defaultValue !== undefined)
+        args.push(defaultValue);
+    return new WindowFunctionBuilder('LEAD', args);
+}
+/** `FIRST_VALUE(expr) OVER (...)` */
+function firstValue(expr) {
+    return new WindowFunctionBuilder('FIRST_VALUE', [expr]);
+}
+/** `LAST_VALUE(expr) OVER (...)` */
+function lastValue(expr) {
+    return new WindowFunctionBuilder('LAST_VALUE', [expr]);
+}
+/** `NTH_VALUE(expr, n) OVER (...)` */
+function nthValue(expr, n) {
+    return new WindowFunctionBuilder('NTH_VALUE', [expr, n]);
+}
+// ---------------------------------------------------------------------------
+// Window-aggregate forms
+// ---------------------------------------------------------------------------
+/** `SUM(expr) OVER (...)` */
+function sumOver(expr) {
+    return new WindowFunctionBuilder('SUM', [expr]);
+}
+/** `AVG(expr) OVER (...)` */
+function avgOver(expr) {
+    return new WindowFunctionBuilder('AVG', [expr]);
+}
+/** `COUNT(expr | *) OVER (...)` */
+function countOver(expr) {
+    if (expr === undefined) {
+        return new WindowFunctionBuilder('COUNT', [(0, operators_1.literalExpr)('*')]);
+    }
+    return new WindowFunctionBuilder('COUNT', [expr]);
+}
+/** `MIN(expr) OVER (...)` */
+function minOver(expr) {
+    return new WindowFunctionBuilder('MIN', [expr]);
+}
+/** `MAX(expr) OVER (...)` */
+function maxOver(expr) {
+    return new WindowFunctionBuilder('MAX', [expr]);
+}
+/**
+ * Generic escape hatch: build a window function call for any function name
+ * not covered by the named helpers above (e.g. dialect-specific analytic
+ * functions).
+ */
+function windowFn(fnName, ...args) {
+    return new WindowFunctionBuilder(fnName.toUpperCase(), args);
+}

package/dist/query-builders/include-builder.js

@@ -0,0 +1,323 @@
+"use strict";
+/**
+ * Include builder for the ORM
+ * Handles JOIN clauses for model associations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncludeBuilder = void 0;
+exports.createIncludeBuilder = createIncludeBuilder;
+exports.buildIncludes = buildIncludes;
+const where_builder_1 = require("./where-builder");
+/**
+ * IncludeBuilder class for building JOIN clauses
+ */
+class IncludeBuilder {
+    /**
+     * Creates a nested WhereBuilder (sharing replacements/model/dialect) used to
+     * render `on`, `where`, and `lateralSubquery.where` clauses on included tables
+     */
+    constructor(options = {}) {
+        this.options = options;
+        this.whereBuilder = new where_builder_1.WhereBuilder({
+            replacements: options.replacements,
+            model: options.model,
+            dialect: options.dialect,
+        });
+    }
+    /**
+     * Build JOIN clauses from include options
+     */
+    build(includes) {
+        const sqlParts = [];
+        const values = [];
+        for (const include of includes) {
+            const result = this.buildInclude(include, values);
+            if (result) {
+                sqlParts.push(result);
+            }
+        }
+        return { sql: sqlParts.join(' '), values };
+    }
+    /**
+     * Build a single include (can handle nested includes)
+     */
+    buildInclude(include, values) {
+        // Determine model and alias
+        const model = include.model;
+        const tableName = model?.tableName || model?.name || String(model);
+        const alias = include.as || tableName;
+        // Get schema from include options (supports joining across schemas)
+        const schema = include.schema;
+        const schemaDelimiter = this.options.schemaDelimiter || '.';
+        // Build table name with schema if specified (e.g., "schema.tableName")
+        const fullTableName = schema ? `${schema}${schemaDelimiter}${tableName}` : tableName;
+        // Handle anti-join (antiJoin or exclude option)
+        const isAntiJoin = include.antiJoin === true || include.exclude === true;
+        // Get anti-join type (defaults to leftJoinIsNull)
+        const antiJoinType = include.antiJoinType || 'leftJoinIsNull';
+        // For notExists and notIn, we handle differently - return null from join and handle in where
+        if (isAntiJoin && (antiJoinType === 'notExists' || antiJoinType === 'notIn')) {
+            // Return empty string - these will be handled in the where clause with subqueries
+            return '';
+        }
+        // Determine join type
+        let joinType = this.getJoinType(include);
+        // For anti-joins with leftJoinIsNull, always use LEFT JOIN
+        if (isAntiJoin && antiJoinType === 'leftJoinIsNull') {
+            joinType = 'LEFT JOIN';
+        }
+        // Build ON clause
+        const onClause = this.buildOnClause(include, fullTableName, alias, values);
+        // Build the JOIN clause
+        let sql = `${joinType} ${this.escapeId(fullTableName)} ${this.escapeId(alias)}`;
+        // Handle CROSS APPLY / OUTER APPLY (SQL Server)
+        if (include.apply) {
+            const applyType = include.apply === 'CROSS' ? 'CROSS APPLY' : 'OUTER APPLY';
+            sql = `${applyType} ${this.escapeId(fullTableName)} ${this.escapeId(alias)}`;
+        }
+        // Handle LATERAL keyword (PostgreSQL only)
+        if (include.lateral) {
+            sql = `${joinType} LATERAL ${this.escapeId(fullTableName)} ${this.escapeId(alias)}`;
+        }
+        // Handle lateralSubquery (inline subquery)
+        if (include.lateralSubquery) {
+            const subqueryModel = include.lateralSubquery.model;
+            const subqueryTableName = subqueryModel?.tableName || subqueryModel?.name || 'subquery';
+            const subqueryAlias = alias;
+            // Build SELECT clause
+            let selectColumns = '*';
+            if (include.lateralSubquery.attributes) {
+                if (Array.isArray(include.lateralSubquery.attributes)) {
+                    selectColumns = include.lateralSubquery.attributes
+                        .map((c) => this.escapeId(c))
+                        .join(', ');
+                }
+                else if (include.lateralSubquery.attributes.include) {
+                    selectColumns = include.lateralSubquery.attributes.include
+                        .map((c) => this.escapeId(c))
+                        .join(', ');
+                }
+            }
+            // Build the lateral subquery
+            let subquery = `SELECT ${selectColumns} FROM ${this.escapeId(subqueryTableName)}`;
+            // Add ON clause if there's a foreign key relationship
+            if (onClause) {
+                subquery += ` ON ${onClause}`;
+            }
+            else {
+                const fk = include.foreignKey;
+                const foreignKey = typeof fk === 'string'
+                    ? fk
+                    : Array.isArray(fk)
+                        ? fk[0]
+                        : fk?.name || this.guessForeignKey(include, tableName);
+                const parentAlias = this.options.parentAlias || 'main';
+                subquery += ` ON ${this.escapeId(parentAlias)}.${this.escapeId(foreignKey)} = ${this.escapeId(subqueryAlias)}.${this.getPrimaryKey(include)}`;
+            }
+            // Add WHERE clause if specified
+            if (include.lateralSubquery.where) {
+                const whereResult = this.whereBuilder.build(include.lateralSubquery.where);
+                if (whereResult.sql) {
+                    subquery += ` AND (${whereResult.sql})`;
+                    values.push(...whereResult.values);
+                }
+            }
+            sql = `${joinType} LATERAL (${subquery}) ${this.escapeId(subqueryAlias)}`;
+        }
+        if (onClause) {
+            sql += ` ON ${onClause}`;
+        }
+        else {
+            // Fallback: use foreign key if not specified
+            const fk = include.foreignKey;
+            const foreignKey = typeof fk === 'string'
+                ? fk
+                : Array.isArray(fk)
+                    ? fk[0]
+                    : fk?.name || this.guessForeignKey(include, tableName);
+            const parentAlias = this.options.parentAlias || 'main';
+            sql += ` ON ${this.escapeId(parentAlias)}.${this.escapeId(foreignKey)} = ${this.escapeId(alias)}.${this.escapeId(this.getPrimaryKey(include))}`;
+        }
+        // Handle through table for many-to-many associations
+        if (include.through) {
+            sql = this.buildThroughJoin(include, sql, values);
+        }
+        // Handle where clause on the joined table
+        if (include.where) {
+            const whereResult = this.whereBuilder.build(include.where);
+            if (whereResult.sql) {
+                sql += ` AND (${whereResult.sql})`;
+                values.push(...whereResult.values);
+            }
+        }
+        // For anti-joins, add WHERE clause to check for NULL (LEFT JOIN WHERE NULL pattern)
+        if (isAntiJoin) {
+            const pk = this.getPrimaryKey(include);
+            sql += ` AND ${this.escapeId(alias)}.${this.escapeId(pk)} IS NULL`;
+        }
+        // Handle nested includes
+        if (include.include && include.include.length > 0) {
+            const nestedBuilder = new IncludeBuilder({
+                ...this.options,
+                parentAlias: alias,
+            });
+            for (const nestedInclude of include.include) {
+                const nestedResult = nestedBuilder.buildInclude(nestedInclude, values);
+                if (nestedResult) {
+                    sql += ` ${nestedResult}`;
+                }
+            }
+        }
+        return sql;
+    }
+    /**
+     * Build a through-table join for many-to-many associations
+     */
+    buildThroughJoin(include, baseJoin, values) {
+        const through = include.through;
+        const throughModel = through?.model;
+        const throughTableName = throughModel?.tableName || throughModel?.name || String(through?.model || 'through');
+        const throughAlias = through?.as || `${throughTableName}_through`;
+        // Build the join through the through table
+        const parentAlias = this.options.parentAlias || 'main';
+        // Use the provided 'as' alias or fall back to table name
+        const targetAlias = include.as || targetTableName(include.model);
+        // We need to modify the base join to go through the through table
+        // This creates: INNER JOIN through_table ON parent.id = through_table.parent_id
+        //               INNER JOIN target_table ON through_table.target_id = target_table.id
+        const parentKey = this.options.parentKey || 'id';
+        const childKey = this.options.childKey || this.getPrimaryKey(include);
+        const throughJoin = `${this.getJoinType(include)} ${this.escapeId(throughTableName)} ${this.escapeId(throughAlias)} ON ${this.escapeId(parentAlias)}.${this.escapeId(parentKey)} = ${this.escapeId(throughAlias)}.${this.escapeId(this.guessForeignKey(include, parentAlias))}`;
+        return `${this.getJoinType(include)} ${this.escapeId(throughTableName)} ${this.escapeId(throughAlias)} ON ${this.escapeId(parentAlias)}.${this.escapeId(parentKey)} = ${this.escapeId(throughAlias)}.${this.guessForeignKey(include, parentAlias)} ${this.getJoinType(include)} ${this.escapeId(targetTableName(include.model))} ${this.escapeId(targetAlias)} ON ${this.escapeId(throughAlias)}.${this.escapeId(childKey)} = ${this.escapeId(targetAlias)}.${this.escapeId(childKey)}`;
+    }
+    /**
+     * Get the join type based on include options
+     */
+    getJoinType(include) {
+        // Check for explicit joinType first
+        if (include.joinType) {
+            switch (include.joinType) {
+                case 'INNER':
+                    return 'INNER JOIN';
+                case 'LEFT':
+                    return 'LEFT JOIN';
+                case 'RIGHT':
+                    return 'RIGHT JOIN';
+                case 'FULL':
+                    return 'FULL OUTER JOIN';
+                case 'CROSS':
+                    return 'CROSS JOIN';
+            }
+        }
+        // Fall back to required flag
+        if (include.required) {
+            return 'INNER JOIN';
+        }
+        // Default to LEFT JOIN for optional associations
+        return 'LEFT JOIN';
+    }
+    /**
+     * Build the ON clause for a join
+     */
+    buildOnClause(include, tableName, alias, values) {
+        // If explicit ON clause is provided
+        if (include.on) {
+            const whereResult = this.whereBuilder.build(include.on);
+            // Need to handle the ON clause differently - it uses the alias
+            return this.buildOnFromWhere(include.on, alias, values);
+        }
+        // Otherwise, try to build from association
+        return null;
+    }
+    /**
+     * Build ON clause from WhereOptions
+     */
+    buildOnFromWhere(on, alias, values) {
+        const onConditions = [];
+        if (typeof on !== 'object') {
+            return '';
+        }
+        for (const [key, value] of Object.entries(on)) {
+            if (key.startsWith('$'))
+                continue;
+            if (typeof value === 'object' && value !== null) {
+                const valueObj = value;
+                // Handle $eq
+                if (valueObj.$eq !== undefined) {
+                    values.push(valueObj.$eq);
+                    onConditions.push(`${alias}.${this.escapeId(key)} = ?`);
+                }
+            }
+            else {
+                values.push(value);
+                onConditions.push(`${alias}.${this.escapeId(key)} = ?`);
+            }
+        }
+        return onConditions.join(' AND ');
+    }
+    /**
+     * Guess the foreign key name for an association
+     */
+    guessForeignKey(include, tableName) {
+        // If foreignKey is explicitly provided
+        if (include.foreignKey) {
+            return typeof include.foreignKey === 'string'
+                ? include.foreignKey
+                : include.foreignKey.name || 'id';
+        }
+        // Default convention: tableName_id
+        const model = include.model;
+        const modelName = model?.name || tableName;
+        return `${modelName.charAt(0).toLowerCase() + modelName.slice(1)}Id`;
+    }
+    /**
+     * Get the primary key of a model
+     */
+    getPrimaryKey(include) {
+        const model = include.model;
+        // Try to get from rawAttributes
+        if (model?.rawAttributes) {
+            for (const [attrName, attr] of Object.entries(model.rawAttributes)) {
+                if (attr.primaryKey) {
+                    return attrName;
+                }
+            }
+        }
+        // Default to 'id'
+        return 'id';
+    }
+    /**
+     * Escape an identifier
+     */
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        if (this.options.dialect?.escapeId) {
+            return this.options.dialect.escapeId(id);
+        }
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+}
+exports.IncludeBuilder = IncludeBuilder;
+/**
+ * Helper to get table name from model
+ */
+function targetTableName(model) {
+    if (typeof model === 'string') {
+        return model;
+    }
+    return model.tableName || model.name || String(model);
+}
+/**
+ * Create an IncludeBuilder instance
+ */
+function createIncludeBuilder(options) {
+    return new IncludeBuilder(options);
+}
+/**
+ * Quick helper to build include JOINs
+ */
+function buildIncludes(includes, options) {
+    const builder = new IncludeBuilder(options);
+    return builder.build(includes);
+}
+exports.default = IncludeBuilder;