ts-prorm-orm 1.1.0 → 1.2.1

package/dist/query-builders/cte-builder.d.ts

@@ -0,0 +1,104 @@
+/**
+ * CTE (Common Table Expression) Builder
+ * Provides an ORM-like way to build CTEs without raw SQL
+ */
+import { FindOptions } from '../types';
+export interface CTEColumn {
+    name: string;
+    type?: string;
+}
+/**
+ * Base CTE definition without raw SQL
+ */
+export interface CTEDefinition {
+    /** Name of the CTE */
+    name: string;
+    /** Column definitions */
+    columns?: CTEColumn[];
+    /** Base case for recursive CTE - can be FindOptions or values */
+    baseCase?: FindOptions | Record<string, any>[];
+    /** Recursive case for recursive CTE */
+    recursiveCase?: FindOptions;
+    /** Non-recursive UNION part */
+    unionWith?: FindOptions;
+    /** Model class or table name */
+    model?: string | {
+        tableName?: string;
+        name?: string;
+    };
+}
+/**
+ * Recursive CTE options for hierarchical data
+ */
+export interface RecursiveCTEOptions {
+    /** CTE name */
+    name: string;
+    /** Columns */
+    columns?: CTEColumn[];
+    /** Anchor/member - starting point */
+    anchor: FindOptions;
+    /** Recursive member - how to get children */
+    recursive: FindOptions;
+    /** Model class or table name for reference */
+    model?: string | {
+        tableName?: string;
+        name?: string;
+    };
+    /** Maximum recursion depth */
+    maxDepth?: number;
+    /** Sort order for results */
+    order?: any[];
+}
+export declare class CTEBuilder {
+    private ctes;
+    /**
+     * Add a simple CTE with a base query
+     * @example
+     * cte.add('active_users', { model: User, baseCase: { where: { active: true } } })
+     * cte.add('active_users', { model: 'users', baseCase: { where: { active: true } } })
+     */
+    add(name: string, options?: {
+        model?: string | {
+            tableName?: string;
+            name?: string;
+        };
+        columns?: CTEColumn[];
+        baseCase?: FindOptions;
+    }): CTEBuilder;
+    /**
+     * Add a recursive CTE for hierarchical data
+     * @example
+     * cte.addRecursive({
+     *   name: 'org_chart',
+     *   model: Employee,
+     *   anchor: { where: { managerId: null } },
+     *   recursive: { where: { '$org_chart.id$': { [Op.eq]: { [Op.col]: 'Employee.managerId' } } } }
+     * })
+     */
+    addRecursive(options: RecursiveCTEOptions): CTEBuilder;
+    /**
+     * Get all CTEs
+     */
+    getCTEs(): CTEDefinition[];
+    /**
+     * Get CTE names
+     */
+    getCTENames(): string[];
+    /**
+     * Build the WITH clause SQL
+     */
+    toSQL(dialect: any): string;
+    /**
+     * Clear all CTEs
+     */
+    clear(): void;
+}
+/**
+ * Create a new CTE builder
+ */
+export declare function createCTEBuilder(): CTEBuilder;
+declare const _default: {
+    CTEBuilder: typeof CTEBuilder;
+    createCTEBuilder: typeof createCTEBuilder;
+};
+export default _default;

package/dist/query-builders/functions/aggregate.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Typed aggregate-function builder API.
+ *
+ * `COUNT`/`SUM`/`AVG`/`MIN`/`MAX` are already reachable through the generic
+ * `fn('SUM', col('amount'))` pattern in `src/operators.ts` because those
+ * names are ANSI-identical across every dialect this ORM supports. This
+ * module fills the real gap: aggregate functions whose *name* (and in some
+ * cases clause placement) differs per dialect, most notably string
+ * aggregation (`GROUP_CONCAT` / `STRING_AGG` / `LISTAGG` / ClickHouse's
+ * array-based approach) and array aggregation (`ARRAY_AGG` / `JSON_ARRAYAGG`
+ * / `groupArray`).
+ *
+ * This module is intentionally self-contained: it does not add any new
+ * dispatch branches to the shared SQL compiler (`src/query-builders/sql-compiler.ts`)
+ * or touch `src/operators.ts`. Every builder function computes a final,
+ * dialect-correct SQL fragment string directly and wraps it with the
+ * existing `literalExpr()` helper from `src/operators.ts` so it slots into
+ * `attributes: [...]` arrays exactly the way `fn()`/`col()`/`cast()` do
+ * today (see `attributeToSql()` in `sql-compiler.ts`, which already knows
+ * how to render `{ __type: 'literal', sql }` and `[expr, alias]` tuples).
+ *
+ * @example
+ * ```typescript
+ * import { count, countDistinct, sum, stringAgg, arrayAgg } from './query-builders/functions/aggregate';
+ * import { col } from '../../operators';
+ *
+ * User.findAll({
+ *   attributes: [
+ *     'department',
+ *     [count('postgres'), 'total'],
+ *     [countDistinct('postgres', col('email')), 'uniqueEmails'],
+ *     [stringAgg('postgres', col('name'), ', ', { orderBy: 'name' }), 'names'],
+ *     [arrayAgg('postgres', col('id')), 'ids'],
+ *   ],
+ *   group: ['department'],
+ * });
+ * ```
+ */
+import { type FnExpression, type ColExpression, type LiteralExpression } from '../../operators';
+import type { Dialect } from '../../types/index';
+/**
+ * Acceptable argument types for aggregate function calls: plain column
+ * names (strings), other typed expressions (`col()`, `fn()`, `literal()`),
+ * or `undefined`/omitted (used for bare `COUNT()`/`COUNT(*)`).
+ */
+export type SqlExpr = string | ColExpression | FnExpression | LiteralExpression;
+/** A single ORDER BY entry, either a bare column name or `{ column, direction }`. */
+export type AggOrderBy = string | {
+    column: string;
+    direction?: 'ASC' | 'DESC';
+} | Array<string | {
+    column: string;
+    direction?: 'ASC' | 'DESC';
+}>;
+export interface StringAggOptions {
+    /** ORDER BY clause applied to the concatenation (single column, or array of columns). */
+    orderBy?: AggOrderBy;
+    /** Whether to deduplicate values before concatenating. */
+    distinct?: boolean;
+}
+export interface ArrayAggOptions {
+    /** ORDER BY clause applied to the aggregation (single column, or array of columns). */
+    orderBy?: AggOrderBy;
+    /** Whether to deduplicate values before aggregating. */
+    distinct?: boolean;
+}
+/**
+ * `COUNT(*)` / `COUNT(expr)` — identical ANSI syntax across all 11 dialects.
+ *
+ * @example
+ * ```typescript
+ * count('postgres')            // -> COUNT(*)
+ * count('postgres', col('id')) // -> COUNT("id")
+ * ```
+ */
+export declare function count(_dialect: Dialect, expr?: SqlExpr): LiteralExpression;
+/**
+ * `COUNT(DISTINCT expr)`.
+ *
+ * Verified across all 11 dialects: MySQL, MariaDB, PostgreSQL, MSSQL,
+ * Oracle, SQLite, CockroachDB, Redshift, Db2, and Snowflake all support the
+ * exact ANSI `COUNT(DISTINCT expr)` syntax. ClickHouse also parses
+ * `COUNT(DISTINCT expr)` (it desugars to an internal uniq-exact
+ * implementation), though ClickHouse users may prefer the native
+ * `uniqExact(expr)` function for clarity/performance on very large
+ * cardinalities — that's a deliberate escape hatch, not a requirement, so
+ * `COUNT(DISTINCT expr)` is used here for consistency with the other
+ * dialects.
+ */
+export declare function countDistinct(_dialect: Dialect, expr: SqlExpr): LiteralExpression;
+/**
+ * `SUM(expr)` — identical everywhere. Note: SUM of an all-NULL group (or
+ * zero input rows) returns SQL NULL (not 0) in every one of these dialects,
+ * so callers should COALESCE(...) explicitly if a numeric default is
+ * required.
+ */
+export declare function sum(_dialect: Dialect, expr: SqlExpr): LiteralExpression;
+/**
+ * `AVG(expr)` — identical everywhere. Note: integer-typed columns are
+ * averaged as an exact/decimal type in PostgreSQL, MSSQL, Oracle, Db2, and
+ * Snowflake, but MySQL/MariaDB/SQLite/ClickHouse promote to floating point;
+ * cast explicitly (e.g. `cast(col('x'), 'DECIMAL(10,2)')`) if exact decimal
+ * averaging is required across dialects.
+ */
+export declare function avg(_dialect: Dialect, expr: SqlExpr): LiteralExpression;
+/** `MIN(expr)` — identical everywhere. */
+export declare function min(_dialect: Dialect, expr: SqlExpr): LiteralExpression;
+/** `MAX(expr)` — identical everywhere. */
+export declare function max(_dialect: Dialect, expr: SqlExpr): LiteralExpression;
+/**
+ * String aggregation (`GROUP_CONCAT` / `STRING_AGG` / `LISTAGG` / ClickHouse
+ * array-concat), dispatched per-dialect. This is the single most
+ * error-prone aggregate across dialects, so each branch below documents the
+ * exact verified syntax.
+ *
+ * - **MySQL / MariaDB**:
+ *   `GROUP_CONCAT([DISTINCT] expr [ORDER BY col [ASC|DESC]] SEPARATOR 'delim')`
+ *   Clause order is fixed: DISTINCT, then the expression, then ORDER BY,
+ *   then SEPARATOR — SEPARATOR must come last and is a keyword, not a comma
+ *   argument.
+ *
+ * - **SQLite**: `GROUP_CONCAT(expr, 'delim')` (2-argument form; the
+ *   separator defaults to `,` if omitted). SQLite's GROUP_CONCAT does
+ *   **not** support an `ORDER BY` clause inside the function call at all —
+ *   if `options.orderBy` is passed for SQLite this throws, since silently
+ *   ignoring it would produce non-deterministic ordering that looks
+ *   intentional. Pre-sort via a subquery/CTE if ordering is required.
+ *   SQLite's DISTINCT variant (`GROUP_CONCAT(DISTINCT expr)`) is supported
+ *   but forces the default comma separator (a custom separator combined
+ *   with DISTINCT is not supported by SQLite) — this also throws if both
+ *   `distinct` and a non-default delimiter are requested together.
+ *
+ * - **PostgreSQL / CockroachDB**: `STRING_AGG([DISTINCT] expr, 'delim' [ORDER BY col [ASC|DESC]])`
+ *   — the ORDER BY clause sits *inside* the same parentheses as the
+ *   delimiter argument (no WITHIN GROUP).
+ *
+ * - **MSSQL**: `STRING_AGG(expr, 'delim') WITHIN GROUP (ORDER BY col [ASC|DESC])`
+ *   — note this is a genuinely different clause *placement* than Postgres:
+ *   the ORDER BY is a separate `WITHIN GROUP (...)` clause appended after
+ *   the function call, not inline inside the argument list. MSSQL's
+ *   `STRING_AGG` also does **not** support a `DISTINCT` argument at all
+ *   (unlike Postgres) — this throws if `distinct: true` is requested.
+ *
+ * - **Oracle / Db2**: `LISTAGG([DISTINCT] expr, 'delim') WITHIN GROUP (ORDER BY col [ASC|DESC])`
+ *   — same WITHIN GROUP placement as MSSQL. Oracle supports `DISTINCT`
+ *   inside LISTAGG since 19c; Db2 LUW's LISTAGG also supports `DISTINCT`.
+ *
+ * - **Redshift**: `LISTAGG([DISTINCT] expr, 'delim') WITHIN GROUP (ORDER BY col [ASC|DESC])`
+ *   — Redshift's aggregate string function has always been `LISTAGG`
+ *   (matching Oracle/Db2 syntax), not `STRING_AGG`. AWS did add a
+ *   Postgres-compatible `STRING_AGG` alias to Redshift more recently, but
+ *   `LISTAGG` is the long-standing, universally-available, and
+ *   ORDER-BY-capable form, so it's used here for correctness.
+ *
+ * - **Snowflake**: `LISTAGG([DISTINCT] expr, 'delim') WITHIN GROUP (ORDER BY col [ASC|DESC])`
+ *   — Snowflake's string aggregation function is `LISTAGG` (Oracle-style),
+ *   *not* `STRING_AGG` — Snowflake has no `STRING_AGG` function.
+ *
+ * - **ClickHouse**: no native `GROUP_CONCAT`/`STRING_AGG`/`LISTAGG`. The
+ *   verified, version-portable idiom is
+ *   `arrayStringConcat(groupArray(expr), 'delim')` (distinct:
+ *   `arrayStringConcat(groupUniqArray(expr), 'delim')`). Newer ClickHouse
+ *   releases (24.x+) also ship a MySQL-compatible `groupConcat(expr)`
+ *   function, but `arrayStringConcat(groupArray(...), ...)` works on every
+ *   supported version so it's used as the default here. ClickHouse's
+ *   `groupArray` has no inline `ORDER BY` sub-clause (it preserves block
+ *   processing order, not a guaranteed sort) — `options.orderBy` therefore
+ *   throws for ClickHouse; pre-sort via a subquery if ordering matters.
+ */
+export declare function stringAgg(dialect: Dialect, expr: SqlExpr, delimiter: string, options?: StringAggOptions): LiteralExpression;
+/**
+ * Aggregate values into an array/JSON-array, dispatched per-dialect.
+ *
+ * - **PostgreSQL / CockroachDB**: native `ARRAY_AGG([DISTINCT] expr [ORDER BY col [ASC|DESC]])`.
+ * - **Snowflake**: native `ARRAY_AGG([DISTINCT] expr) [WITHIN GROUP (ORDER BY col [ASC|DESC])]`
+ *   — Snowflake's ARRAY_AGG uses the same WITHIN GROUP placement as LISTAGG,
+ *   not Postgres's inline ORDER BY.
+ * - **ClickHouse**: native `groupArray(expr)` (distinct: `groupUniqArray(expr)`);
+ *   returns ClickHouse's native Array(T) type. No inline ORDER BY support
+ *   (same limitation as `stringAgg`) — throws if `orderBy` is requested.
+ * - **MySQL (5.7.22+) / MariaDB (10.5+)**: no `ARRAY_AGG`, but both support
+ *   the real `JSON_ARRAYAGG(expr)` function, used here as a JSON-array
+ *   fallback. Neither dialect's `JSON_ARRAYAGG` supports `DISTINCT` or
+ *   `ORDER BY` — both throw if requested.
+ * - **Oracle (12.2+) / Db2 (11.5+)**: no `ARRAY_AGG`, but both support the
+ *   real SQL:2016 `JSON_ARRAYAGG(expr)` function, used as a JSON-array
+ *   fallback here too. `DISTINCT`/`ORDER BY` throw (not supported by either
+ *   engine's JSON_ARRAYAGG).
+ * - **SQLite**: no `ARRAY_AGG`, but has the real native `json_group_array(expr)`
+ *   aggregate, used as the fallback. `DISTINCT`/`ORDER BY` throw (not
+ *   supported by SQLite's json_group_array).
+ * - **MSSQL / Redshift**: no real array-aggregation concept and no reliable
+ *   scalar-aggregate JSON-array equivalent (MSSQL's JSON array construction
+ *   is via `FOR JSON PATH` on a full query shape, not an aggregate function
+ *   usable inline in a SELECT list; Redshift has no JSON_ARRAYAGG). Both
+ *   throw a clear "not supported" error rather than faking an unreliable
+ *   workaround.
+ */
+export declare function arrayAgg(dialect: Dialect, expr: SqlExpr, options?: ArrayAggOptions): LiteralExpression;

package/dist/query-builders/functions/conditional.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Typed CASE WHEN ... THEN ... ELSE ... END expression builder.
+ *
+ * `CASE WHEN` is ANSI-standard SQL (SQL-92) and is supported identically,
+ * with no syntax variation, across every dialect this ORM targets:
+ *   - mysql, mariadb: full support (searched + simple CASE)
+ *   - postgres, cockroachdb, redshift: full support (Postgres-derived)
+ *   - mssql: full support (T-SQL CASE is ANSI-compliant)
+ *   - oracle: full support (in addition to the older DECODE() function,
+ *     Oracle has supported standard CASE since 9i)
+ *   - sqlite: full support
+ *   - db2: full support
+ *   - snowflake: full support
+ *   - clickhouse: full support, including both the "searched" form
+ *     (`CASE WHEN cond THEN a END`) and the "simple" form
+ *     (`CASE expr WHEN val THEN a END`). ClickHouse also offers the
+ *     `multiIf()`/`if()` functions as engine-native alternatives, but plain
+ *     `CASE` works exactly as ANSI SQL specifies, so no dialect branching is
+ *     required here (unlike window frame extensions or JSON path functions).
+ *
+ * This module is intentionally self-contained: it does not add any new
+ * dispatch branches to the shared SQL compiler (`src/query-builders/sql-compiler.ts`)
+ * or to `src/operators.ts`. Every builder resolves directly to a final SQL
+ * fragment string, which is then wrapped with the existing `literalExpr()`
+ * helper from `src/operators.ts` so it slots into `attributes: [...]` arrays
+ * exactly the way `fn()`/`col()`/`cast()`/the window-function builder do
+ * today (see `attributeToSql()` in `sql-compiler.ts`, which already knows
+ * how to render `{ __type: 'literal', sql }` and `[expr, alias]` tuples).
+ *
+ * Condition syntax: `.when()` on the searched-CASE builder (`caseWhen()`)
+ * accepts the SAME condition-object shape already used by `where:` clauses
+ * throughout this ORM (see `src/operators.ts`'s `Op` symbols and
+ * `src/query-builders/where-builder.ts`), e.g.:
+ *
+ *   { age: { [Op.gte]: 18 } }
+ *   { [Op.and]: [{ age: { [Op.gte]: 18 } }, { status: 'active' }] }
+ *   { [Op.between]: [...] } // via a field key, see below
+ *
+ * rather than inventing a new mini-language. This keeps `caseWhen().when(...)`
+ * consistent with `Model.findAll({ where: ... })` conditions. A shorthand
+ * 3-arg form, `.when(column, operator, value, thenValue)`, is also supported
+ * for ergonomic simple comparisons (mirroring `Op.where(col, op, value)`).
+ *
+ * @example
+ * ```typescript
+ * import { caseWhen, caseOf } from './query-builders/functions/conditional';
+ * import { Op, col } from '../../operators';
+ *
+ * // Searched CASE (condition-object form, same shape as `where:`)
+ * User.findAll({
+ *   attributes: [
+ *     'name',
+ *     caseWhen()
+ *       .when({ age: { [Op.gte]: 18 } }, 'adult')
+ *       .when({ age: { [Op.gte]: 13 } }, 'teen')
+ *       .else('child')
+ *       .as('ageGroup'),
+ *   ],
+ * });
+ *
+ * // Searched CASE (3-arg shorthand form)
+ * caseWhen().when('age', '>=', 18, 'adult').else('minor').as('ageGroup');
+ *
+ * // Simple CASE (CASE expr WHEN val THEN result ... END)
+ * caseOf(col('status'))
+ *   .when('active', 1)
+ *   .when('inactive', 0)
+ *   .else(null)
+ *   .as('statusFlag');
+ *
+ * // Nested CASE
+ * caseWhen()
+ *   .when({ age: { [Op.gte]: 65 } }, 'senior')
+ *   .else(caseWhen().when({ age: { [Op.gte]: 18 } }, 'adult').else('minor'))
+ *   .as('category');
+ * ```
+ */
+import { type FnExpression, type ColExpression, type LiteralExpression, type OperatorSymbol } from '../../operators';
+/**
+ * Acceptable "value" arguments for THEN/ELSE results and simple-CASE
+ * WHEN-values: plain strings/numbers (escaped as SQL literals), `null`
+ * (rendered as SQL NULL), typed expressions (`col()`, `fn()`, `literal()`),
+ * or a nested CASE builder (`CaseBuilder`/`SimpleCaseBuilder`) so CASE
+ * expressions can be composed inside one another.
+ */
+export type CaseValue = string | number | boolean | ColExpression | FnExpression | LiteralExpression | {
+    $literal: string;
+} | CaseBuilder | SimpleCaseBuilder | null;
+/**
+ * A condition accepted by `CaseBuilder.when()`. Uses the same shape as
+ * `where:` clause condition objects elsewhere in this ORM, e.g.:
+ *   { age: { [Op.gte]: 18 } }
+ *   { [Op.and]: [...] } / { $and: [...] }
+ *   { status: 'active' } (implicit equality)
+ */
+export type CaseCondition = Record<string | symbol, any>;
+/**
+ * Fluent builder for a "searched" CASE expression:
+ *   CASE WHEN cond1 THEN result1 WHEN cond2 THEN result2 ... ELSE else END
+ *
+ * Build with `caseWhen()`. Terminate with `.as(alias)` (for use directly in
+ * an `attributes: [...]` array) or `.toSQL()` / `.toLiteral()`.
+ */
+export declare class CaseBuilder {
+    private clauses;
+    private elseSql;
+    private hasElse;
+    /**
+     * Add a `WHEN <condition> THEN <thenValue>` branch. Repeatable — call
+     * multiple times to add multiple branches, evaluated in order.
+     *
+     * Two call forms are supported:
+     *  - `.when(conditionObject, thenValue)` — condition object using the
+     *    same shape as `where:` clauses (`{ age: { [Op.gte]: 18 } }`, nested
+     *    `Op.and`/`Op.or`, etc.)
+     *  - `.when(column, operator, value, thenValue)` — ergonomic shorthand
+     *    for a single comparison (mirrors `Op.where(col, op, value)`).
+     */
+    when(condition: CaseCondition, thenValue: CaseValue): this;
+    when(column: string, operator: string | OperatorSymbol, value: unknown, thenValue: CaseValue): this;
+    /** Set the `ELSE <value>` branch. Optional — omitting it yields an implicit SQL NULL. */
+    else(value: CaseValue): this;
+    /** Render the `CASE WHEN ... END` SQL fragment (no alias). */
+    toSQL(): string;
+    /**
+     * Terminal call: returns an `[expr, alias]` tuple compatible with the
+     * existing `attributes: [...]` pattern (see `attributeToSql()` in
+     * `sql-compiler.ts`, which already knows how to render
+     * `[LiteralExpression, alias]` tuples without any core changes).
+     */
+    as(alias: string): [LiteralExpression, string];
+    /** Use the builder directly wherever a raw SQL literal expression is expected. */
+    toLiteral(): LiteralExpression;
+}
+/**
+ * Fluent builder for a "simple" CASE expression:
+ *   CASE expr WHEN val1 THEN result1 WHEN val2 THEN result2 ... ELSE else END
+ *
+ * Build with `caseOf(expr)`. Terminate with `.as(alias)` or `.toSQL()` /
+ * `.toLiteral()`.
+ */
+export declare class SimpleCaseBuilder {
+    private readonly exprSql;
+    private clauses;
+    private elseSql;
+    private hasElse;
+    constructor(expr: CaseValue | string);
+    /**
+     * Add a `WHEN <value> THEN <result>` branch. Repeatable — call multiple
+     * times to add multiple branches, evaluated in order.
+     */
+    when(value: CaseValue, result: CaseValue): this;
+    /** Set the `ELSE <value>` branch. Optional — omitting it yields an implicit SQL NULL. */
+    else(value: CaseValue): this;
+    /** Render the `CASE expr WHEN ... END` SQL fragment (no alias). */
+    toSQL(): string;
+    /**
+     * Terminal call: returns an `[expr, alias]` tuple compatible with the
+     * existing `attributes: [...]` pattern.
+     */
+    as(alias: string): [LiteralExpression, string];
+    /** Use the builder directly wherever a raw SQL literal expression is expected. */
+    toLiteral(): LiteralExpression;
+}
+/**
+ * Start a "searched" CASE expression:
+ *   CASE WHEN cond1 THEN result1 [WHEN cond2 THEN result2 ...] [ELSE else] END
+ *
+ * @example
+ * ```typescript
+ * caseWhen()
+ *   .when({ age: { [Op.gte]: 18 } }, 'adult')
+ *   .else('minor')
+ *   .as('ageGroup')
+ * ```
+ */
+export declare function caseWhen(): CaseBuilder;
+/**
+ * Start a "simple" CASE expression:
+ *   CASE expr WHEN val1 THEN result1 [WHEN val2 THEN result2 ...] [ELSE else] END
+ *
+ * @param expr - The expression being compared. A plain string is treated as
+ *   a column name (identifier-escaped); pass `col('name')`, `fn(...)`, or
+ *   `literal(...)` for other expression types.
+ *
+ * @example
+ * ```typescript
+ * caseOf('status')
+ *   .when('active', 1)
+ *   .when('inactive', 0)
+ *   .else(null)
+ *   .as('statusFlag')
+ * ```
+ */
+export declare function caseOf(expr: CaseValue | string): SimpleCaseBuilder;