@c9up/atlas 0.2.5 → 0.2.7

package/dist/schema/TableBuilder.js

@@ -45,6 +45,195 @@ export class ForeignKeyBuilder {
         return this;
     }
 }
+/**
+ * The chainable a column-type method hands back — Knex's `ColumnBuilder`.
+ *
+ * It is bound to ITS OWN column, which is what lets `table.comment()` mean the
+ * table comment and `table.string('x').comment()` the column one. A builder
+ * flattened onto the table cannot tell those apart, and Knex has both.
+ */
+export class ColumnBuilder {
+    #table;
+    #column;
+    constructor(table, column) {
+        this.#table = table;
+        this.#column = column;
+    }
+    notNullable() {
+        this.#column.nullable = false;
+        this.#table.markNullabilityTouched();
+        return this;
+    }
+    nullable() {
+        this.#column.nullable = true;
+        this.#table.markNullabilityTouched();
+        return this;
+    }
+    /**
+     * Set a column default. JS literals are quoted/escaped (`'x'`, `123`,
+     * `true` — Lucid/Knex semantics); wrap SQL expressions in {@link raw} (or
+     * use `Migration.now()`) to emit them verbatim.
+     */
+    defaultTo(value) {
+        this.#column.defaultValue = renderDefaultValue(value);
+        return this;
+    }
+    /** MySQL `UNSIGNED` numeric modifier (Lucid `unsigned()`). No-op on pg/sqlite. */
+    unsigned() {
+        this.#column.unsigned = true;
+        return this;
+    }
+    /**
+     * Declare the current column a foreign key.
+     *
+     * - `references('users', 'id')` — atlas form `(table, column='id')`.
+     * - `references('users.id')` — Lucid/Knex dotted `'table.column'` shorthand, so
+     *   a migration copied from Lucid resolves the target the same way. A single
+     *   argument without a dot is treated as the table name (column defaults to
+     *   `id`), preserving the atlas one-arg behaviour.
+     */
+    references(tableOrPath, column) {
+        let table = tableOrPath;
+        let col = column ?? "id";
+        const dot = tableOrPath.indexOf(".");
+        // Dotted shorthand only when no explicit column was passed — an explicit
+        // second arg always wins, so `references('a.b', 'c')` stays (table 'a.b').
+        if (dot !== -1 && column === undefined) {
+            table = tableOrPath.slice(0, dot);
+            col = tableOrPath.slice(dot + 1);
+        }
+        this.#column.references = { table, column: col };
+        return this;
+    }
+    /**
+     * Referential action for the current column's foreign key `ON DELETE`
+     * (Lucid parity). Must follow {@link references}.
+     */
+    onDelete(action) {
+        if (this.#column.references) {
+            this.#column.references.onDelete = action;
+        }
+        return this;
+    }
+    /** Referential action for the current column's foreign key `ON UPDATE`. Must follow {@link references}. */
+    onUpdate(action) {
+        if (this.#column.references) {
+            this.#column.references.onUpdate = action;
+        }
+        return this;
+    }
+    /**
+     * Comment this column (Lucid/Knex column `comment()`). Inline on MySQL, a
+     * separate `COMMENT ON COLUMN` on Postgres, dropped on SQLite. The TABLE
+     * comment is `table.comment()` — the receiver tells them apart, as in Knex.
+     */
+    comment(text) {
+        this.#column.comment = text;
+        return this;
+    }
+    /** Collate this column (Lucid/Knex column `collate()`). The table collation is `table.collate()`. */
+    collate(collation) {
+        this.#column.collate = collation;
+        return this;
+    }
+    /**
+     * Place an added column first (Lucid/Knex `first()`). MySQL-only —
+     * Postgres and SQLite always append, and the Rust compiler raises
+     * `E_UNSUPPORTED` rather than dropping the instruction silently.
+     */
+    first() {
+        this.#column.position = { at: "first" };
+        return this;
+    }
+    /** Place an added column after `column` (Lucid/Knex `after()`). MySQL-only — see {@link first}. */
+    after(column) {
+        this.#column.position = { at: "after", column };
+        return this;
+    }
+    // ─── CHECK constraints ────────────────────────────────────
+    /** `CHECK (col > 0)` on this column (Lucid/Knex `checkPositive`). */
+    checkPositive(constraintName) {
+        this.#table.addColumnCheck(this.#column.name, (column) => ({ check: "positive", column }), constraintName);
+        return this;
+    }
+    /** `CHECK (col < 0)` on this column (Lucid/Knex `checkNegative`). */
+    checkNegative(constraintName) {
+        this.#table.addColumnCheck(this.#column.name, (column) => ({ check: "negative", column }), constraintName);
+        return this;
+    }
+    /** `CHECK (col IN (…))` on this column (Lucid/Knex `checkIn`). Values are quoted, never interpolated raw. */
+    checkIn(values, constraintName) {
+        this.#table.addColumnCheck(this.#column.name, (column) => ({ check: "in", column, values: [...values] }), constraintName);
+        return this;
+    }
+    /** `CHECK (col NOT IN (…))` on this column (Lucid/Knex `checkNotIn`). */
+    checkNotIn(values, constraintName) {
+        this.#table.addColumnCheck(this.#column.name, (column) => ({ check: "notIn", column, values: [...values] }), constraintName);
+        return this;
+    }
+    /**
+     * `CHECK (col BETWEEN lo AND hi)` on this column (Lucid/Knex
+     * `checkBetween`). Accepts one `[min, max]` interval or a list of them —
+     * several intervals are OR'd together, as in Knex.
+     */
+    checkBetween(range, constraintName) {
+        // A single [min, max] vs a list of intervals: the first element of a
+        // list-of-intervals is itself an array.
+        const ranges = Array.isArray(range[0])
+            ? range.map((r) => [...r])
+            : [[...range]];
+        this.#table.addColumnCheck(this.#column.name, (column) => ({ check: "between", column, ranges }), constraintName);
+        return this;
+    }
+    /** `CHECK (LENGTH(col) <op> n)` on this column (Lucid/Knex `checkLength`). The operator is allow-listed by the Rust compiler. */
+    checkLength(operator, length, constraintName) {
+        this.#table.addColumnCheck(this.#column.name, (column) => ({ check: "length", column, operator, length }), constraintName);
+        return this;
+    }
+    /**
+     * `CHECK (col ~ 'pattern')` on this column (Lucid/Knex `checkRegex`).
+     * Postgres spells it `~`; MySQL and SQLite use `REGEXP`.
+     *
+     * SQLite parses `REGEXP` but ships no implementation — the constraint only
+     * works if the connection registers a `regexp` function. Knex behaves the
+     * same way, so this is parity rather than a new trap, but it is worth
+     * knowing before you rely on it there.
+     */
+    checkRegex(pattern, constraintName) {
+        this.#table.addColumnCheck(this.#column.name, (column) => ({ check: "regex", column, pattern }), constraintName);
+        return this;
+    }
+    /** Mark this column the primary key (Lucid/Knex column `primary()`). */
+    primary() {
+        this.#column.primary = true;
+        return this;
+    }
+    /** Mark this column `UNIQUE` (Lucid/Knex column `unique()`). */
+    unique() {
+        this.#column.unique = true;
+        return this;
+    }
+    /** Index this column (Lucid/Knex column `index()`). */
+    index(name) {
+        this.#table.index(this.#column.name, name);
+        return this;
+    }
+    /**
+     * Apply this definition as a type change instead of an `ADD COLUMN`
+     * (Lucid/Knex `alter()`).
+     *
+     * Nullability moves only if `.nullable()` / `.notNullable()` was called
+     * before this — a bare `t.string('x').alter()` changes the type and leaves
+     * the NOT NULL constraint exactly as it is.
+     *
+     * SQLite cannot alter a column in place; the Rust compiler rejects it with
+     * `E_UNSUPPORTED` rather than emitting a table rebuild behind your back.
+     */
+    alter() {
+        this.#table.alterPendingColumn();
+        return this;
+    }
+}
 /** Table builder — used inside `schema.createTable(name, callback)`. */
 export class TableBuilder {
     tableName;
@@ -88,10 +277,10 @@ export class TableBuilder {
         return this.#addIncrements(name, "bigInteger");
     }
     string(name, length = 255) {
-        this.#addColumn(name, "string");
+        const column = this.#addColumn(name, "string");
         if (this.#currentColumn)
             this.#currentColumn.length = length;
-        return this;
+        return column;
     }
     /**
      * Text column (Lucid/Knex `text(name, textType)`). `textType` widens the
@@ -120,12 +309,12 @@ export class TableBuilder {
         return this.#addColumn(name, "bigInteger");
     }
     decimal(name, precision = 10, scale = 2) {
-        this.#addColumn(name, "decimal");
+        const column = this.#addColumn(name, "decimal");
         if (this.#currentColumn) {
             this.#currentColumn.precision = precision;
             this.#currentColumn.scale = scale;
         }
-        return this;
+        return column;
     }
     /**
      * Single-precision float (Lucid `float`). `REAL` on pg/sqlite, `FLOAT` on
@@ -151,10 +340,10 @@ export class TableBuilder {
      * which has no time type to carry it).
      */
     time(name, precision) {
-        this.#addColumn(name, "time");
+        const column = this.#addColumn(name, "time");
         if (this.#currentColumn)
             this.#currentColumn.precision = precision;
-        return this;
+        return column;
     }
     /**
      * Timestamp column (Lucid `timestamp(name, options)`).
@@ -165,10 +354,10 @@ export class TableBuilder {
      * timestamps as TEXT).
      */
     timestamp(name, options = {}) {
-        this.#addColumn(name, options.useTz ? "timestamptz" : "timestamp");
+        const column = this.#addColumn(name, options.useTz ? "timestamptz" : "timestamp");
         if (this.#currentColumn)
             this.#currentColumn.precision = options.precision;
-        return this;
+        return column;
     }
     /** Alias of {@link timestamp} (Lucid `dateTime`). Use `{ useTz: true }` or {@link timestamptz} for a tz-aware column. */
     dateTime(name, options = {}) {
@@ -192,12 +381,6 @@ export class TableBuilder {
     /**
      * Binary JSON (Lucid/Knex `jsonb`). `JSONB` on pg, `JSON` on MySQL, `TEXT`
      * on SQLite.
-     *
-     * Deviation, named: atlas's {@link json} already maps to `JSONB` on
-     * Postgres (it predates this method), where Lucid's `json()` maps to
-     * `json`. Leaving `json()` alone avoids silently rewriting the physical
-     * type of existing columns and desyncing `SchemaCheck`, so on Postgres the
-     * two spellings coincide.
      */
     jsonb(name) {
         return this.#addColumn(name, "jsonb");
@@ -207,10 +390,10 @@ export class TableBuilder {
      * SQLite; on MySQL `length` selects `VARBINARY(n)` over `BLOB`.
      */
     binary(name, length) {
-        this.#addColumn(name, "binary");
+        const column = this.#addColumn(name, "binary");
         if (this.#currentColumn)
             this.#currentColumn.length = length;
-        return this;
+        return column;
     }
     /**
      * A column typed with a verbatim dialect type (Lucid/Knex `specificType`) —
@@ -223,10 +406,10 @@ export class TableBuilder {
      * argument list) and rejects anything else with `E_UNSAFE_SQL`.
      */
     specificType(name, type) {
-        this.#addColumn(name, "specificType");
+        const column = this.#addColumn(name, "specificType");
         if (this.#currentColumn)
             this.#currentColumn.rawType = type;
-        return this;
+        return column;
     }
     /**
      * Fixed value-set column (Lucid `enum`). MySQL renders a native `ENUM(...)`;
@@ -234,10 +417,10 @@ export class TableBuilder {
      * value set. At least one value is required.
      */
     enum(name, values) {
-        this.#addColumn(name, "enum");
+        const column = this.#addColumn(name, "enum");
         if (this.#currentColumn)
             this.#currentColumn.values = values;
-        return this;
+        return column;
     }
     // ─── Shortcuts ────────────────────────────────────────────
     /**
@@ -299,179 +482,21 @@ export class TableBuilder {
      */
     timestamps(useTimestamps = true, defaultToNow = true) {
         const add = (name) => {
-            if (useTimestamps)
-                this.timestamp(name);
-            else
-                this.dateTime(name);
+            const column = useTimestamps ? this.timestamp(name) : this.dateTime(name);
             if (defaultToNow) {
-                this.notNullable().defaultTo(new RawSql("CURRENT_TIMESTAMP"));
+                column.notNullable().defaultTo(new RawSql("CURRENT_TIMESTAMP"));
             }
         };
         add("created_at");
         add("updated_at");
         return this;
     }
-    // ─── Column modifiers ─────────────────────────────────────
-    notNullable() {
-        if (this.#currentColumn)
-            this.#currentColumn.nullable = false;
-        this.#nullabilityTouched = true;
-        return this;
-    }
-    nullable() {
-        if (this.#currentColumn)
-            this.#currentColumn.nullable = true;
-        this.#nullabilityTouched = true;
-        return this;
-    }
-    /**
-     * Set a column default. JS literals are quoted/escaped (`'x'`, `123`,
-     * `true` — Lucid/Knex semantics); wrap SQL expressions in {@link raw} (or
-     * use `Migration.now()`) to emit them verbatim.
-     */
-    defaultTo(value) {
-        if (this.#currentColumn) {
-            this.#currentColumn.defaultValue = renderDefaultValue(value);
-        }
-        return this;
-    }
-    /** MySQL `UNSIGNED` numeric modifier (Lucid `unsigned()`). No-op on pg/sqlite. */
-    unsigned() {
-        if (this.#currentColumn)
-            this.#currentColumn.unsigned = true;
-        return this;
-    }
-    /**
-     * Declare the current column a foreign key.
-     *
-     * - `references('users', 'id')` — atlas form `(table, column='id')`.
-     * - `references('users.id')` — Lucid/Knex dotted `'table.column'` shorthand, so
-     *   a migration copied from Lucid resolves the target the same way. A single
-     *   argument without a dot is treated as the table name (column defaults to
-     *   `id`), preserving the atlas one-arg behaviour.
-     */
-    references(tableOrPath, column) {
-        let table = tableOrPath;
-        let col = column ?? "id";
-        const dot = tableOrPath.indexOf(".");
-        // Dotted shorthand only when no explicit column was passed — an explicit
-        // second arg always wins, so `references('a.b', 'c')` stays (table 'a.b').
-        if (dot !== -1 && column === undefined) {
-            table = tableOrPath.slice(0, dot);
-            col = tableOrPath.slice(dot + 1);
-        }
-        if (this.#currentColumn) {
-            this.#currentColumn.references = { table, column: col };
-        }
-        return this;
-    }
-    /**
-     * Referential action for the current column's foreign key `ON DELETE`
-     * (Lucid parity). Must follow {@link references}.
-     */
-    onDelete(action) {
-        if (this.#currentColumn?.references) {
-            this.#currentColumn.references.onDelete = action;
-        }
-        return this;
-    }
-    /** Referential action for the current column's foreign key `ON UPDATE`. Must follow {@link references}. */
-    onUpdate(action) {
-        if (this.#currentColumn?.references) {
-            this.#currentColumn.references.onUpdate = action;
-        }
-        return this;
-    }
-    /**
-     * Comment the current **column** (Lucid/Knex column `comment()`). Inline on
-     * MySQL, a separate `COMMENT ON COLUMN` on Postgres, dropped on SQLite.
-     *
-     * Deviation, named: Knex's `table.comment()` is the TABLE comment, because
-     * its column methods return a separate column builder. Atlas flattens the
-     * column modifiers onto the table builder (`.notNullable()`, `.unique()`,
-     * `.defaultTo()` all work this way), so `comment()` follows that same rule
-     * and the table comment is {@link tableComment}. Resolving it by "is a
-     * column pending?" would be exactly the kind of guessing that bites later.
-     */
-    comment(text) {
-        if (this.#currentColumn)
-            this.#currentColumn.comment = text;
-        return this;
-    }
-    /** Collate the current **column** (Lucid/Knex column `collate()`). See {@link comment} for why the table form is {@link tableCollate}. */
-    collate(collation) {
-        if (this.#currentColumn)
-            this.#currentColumn.collate = collation;
-        return this;
-    }
-    /**
-     * Place an added column first (Lucid/Knex `first()`). MySQL-only —
-     * Postgres and SQLite always append, and the Rust compiler raises
-     * `E_UNSUPPORTED` rather than dropping the instruction silently.
-     */
-    first() {
-        if (this.#currentColumn)
-            this.#currentColumn.position = { at: "first" };
-        return this;
-    }
-    /** Place an added column after `column` (Lucid/Knex `after()`). MySQL-only — see {@link first}. */
-    after(column) {
-        if (this.#currentColumn) {
-            this.#currentColumn.position = { at: "after", column };
-        }
-        return this;
-    }
     // ─── CHECK constraints ────────────────────────────────────
-    /** `CHECK (col > 0)` on the current column (Lucid/Knex `checkPositive`). */
-    checkPositive(constraintName) {
-        return this.#addCheck((column) => ({ check: "positive", column }), constraintName);
-    }
-    /** `CHECK (col < 0)` on the current column (Lucid/Knex `checkNegative`). */
-    checkNegative(constraintName) {
-        return this.#addCheck((column) => ({ check: "negative", column }), constraintName);
-    }
-    /** `CHECK (col IN (…))` on the current column (Lucid/Knex `checkIn`). Values are quoted, never interpolated raw. */
-    checkIn(values, constraintName) {
-        return this.#addCheck((column) => ({ check: "in", column, values: [...values] }), constraintName);
-    }
-    /** `CHECK (col NOT IN (…))` on the current column (Lucid/Knex `checkNotIn`). */
-    checkNotIn(values, constraintName) {
-        return this.#addCheck((column) => ({ check: "notIn", column, values: [...values] }), constraintName);
-    }
-    /**
-     * `CHECK (col BETWEEN lo AND hi)` on the current column (Lucid/Knex
-     * `checkBetween`). Accepts one `[min, max]` interval or a list of them —
-     * several intervals are OR'd together, as in Knex.
-     */
-    checkBetween(range, constraintName) {
-        // A single [min, max] vs a list of intervals: the first element of a
-        // list-of-intervals is itself an array.
-        const ranges = Array.isArray(range[0])
-            ? range.map((r) => [...r])
-            : [[...range]];
-        return this.#addCheck((column) => ({ check: "between", column, ranges }), constraintName);
-    }
-    /** `CHECK (LENGTH(col) <op> n)` on the current column (Lucid/Knex `checkLength`). The operator is allow-listed by the Rust compiler. */
-    checkLength(operator, length, constraintName) {
-        return this.#addCheck((column) => ({ check: "length", column, operator, length }), constraintName);
-    }
-    /**
-     * `CHECK (col ~ 'pattern')` on the current column (Lucid/Knex `checkRegex`).
-     * Postgres spells it `~`; MySQL and SQLite use `REGEXP`.
-     *
-     * SQLite parses `REGEXP` but ships no implementation — the constraint only
-     * works if the connection registers a `regexp` function. Knex behaves the
-     * same way, so this is parity rather than a new trap, but it is worth
-     * knowing before you rely on it there.
-     */
-    checkRegex(pattern, constraintName) {
-        return this.#addCheck((column) => ({ check: "regex", column, pattern }), constraintName);
-    }
     /**
      * A free-form `CHECK (predicate)` (Lucid/Knex `check`). The predicate is
      * emitted verbatim — exactly as trusted as {@link Schema.raw}, so never
-     * build it from user input. Prefer the typed `check*` helpers, which are
-     * safe by construction.
+     * build it from user input. Prefer the typed `check*` helpers on the column
+     * builder, which are safe by construction.
      */
     check(predicate, constraintName) {
         this.#pushConstraint({
@@ -490,17 +515,8 @@ export class TableBuilder {
         return this;
     }
     // ─── Table-level constraints ──────────────────────────────
-    /**
-     * With no argument, mark the current column as the primary key (the
-     * existing column modifier). With a column list, declare a composite
-     * `PRIMARY KEY (…)` table constraint (Lucid/Knex `primary([...])`).
-     */
+    /** Composite `PRIMARY KEY (…)` table constraint (Lucid/Knex `primary([...])`). */
     primary(columns, constraintName) {
-        if (columns === undefined) {
-            if (this.#currentColumn)
-                this.#currentColumn.primary = true;
-            return this;
-        }
         this.#pushConstraint({
             constraint: "primary",
             name: constraintName,
@@ -509,19 +525,12 @@ export class TableBuilder {
         return this;
     }
     /**
-     * With no argument, mark the current column `UNIQUE` (the existing column
-     * modifier). With a column list, declare a composite `UNIQUE (…)` table
-     * constraint (Lucid/Knex `unique([...])`).
+     * Composite `UNIQUE (…)` table constraint (Lucid/Knex `unique([...])`).
      *
      * Note this is a real constraint, unlike {@link uniqueIndex}, which creates
      * a separate `CREATE UNIQUE INDEX`.
      */
     unique(columns, constraintName) {
-        if (columns === undefined) {
-            if (this.#currentColumn)
-                this.#currentColumn.unique = true;
-            return this;
-        }
         this.#pushConstraint({
             constraint: "unique",
             name: constraintName ?? this.#constraintName(columns, "unique"),
@@ -588,13 +597,13 @@ export class TableBuilder {
         this.#options.charset = name;
         return this;
     }
-    /** MySQL default collation for the table. Named `tableCollate` because {@link collate} is the column modifier — see {@link comment}. */
-    tableCollate(name) {
+    /** MySQL default collation for the table (Lucid/Knex `collate`). The column form is `table.<type>(…).collate()`. */
+    collate(name) {
         this.#options.collate = name;
         return this;
     }
-    /** Table comment. Named `tableComment` because {@link comment} is the column modifier — see there for why. */
-    tableComment(text) {
+    /** Table comment (Lucid/Knex `comment`). The column form is `table.<type>(…).comment()`. */
+    comment(text) {
         this.#options.comment = text;
         return this;
     }
@@ -620,16 +629,9 @@ export class TableBuilder {
     // ─── ALTER TABLE operations ───────────────────────────────
     /**
      * Apply the pending column definition as a type change instead of an
-     * `ADD COLUMN` (Lucid/Knex `alter()`). Must follow a column-type method.
-     *
-     * Nullability moves only if `.nullable()` / `.notNullable()` was called
-     * before this — a bare `t.string('x').alter()` changes the type and leaves
-     * the NOT NULL constraint exactly as it is.
-     *
-     * SQLite cannot alter a column in place; the Rust compiler rejects it with
-     * `E_UNSUPPORTED` rather than emitting a table rebuild behind your back.
+     * @internal Backs `ColumnBuilder.alter()`.
      */
-    alter() {
+    alterPendingColumn() {
         this.#assertAlterMode("alter()");
         const pending = this.#currentOp;
         if (!pending) {
@@ -646,7 +648,18 @@ export class TableBuilder {
             this.#operations[this.#operations.indexOf(pending)] = converted;
             this.#currentOp = converted;
         }
-        return this;
+    }
+    /** @internal Backs `ColumnBuilder.nullable()` / `.notNullable()`. */
+    markNullabilityTouched() {
+        this.#nullabilityTouched = true;
+    }
+    /** @internal Backs the `ColumnBuilder.check*()` helpers, for a named column. */
+    addColumnCheck(column, build, constraintName) {
+        this.#pushConstraint({
+            constraint: "check",
+            name: constraintName,
+            expr: build(column),
+        });
     }
     /** Drop a column (Lucid/Knex `dropColumn`). */
     dropColumn(name) {
@@ -782,18 +795,6 @@ export class TableBuilder {
         }
     }
     /** Build a CHECK against the pending column. */
-    #addCheck(build, constraintName) {
-        const column = this.#currentColumn?.name;
-        if (!column) {
-            throw new Error("E_CHECK_MISUSE: a check* helper must follow a column definition, e.g. table.integer('qty').checkPositive()");
-        }
-        this.#pushConstraint({
-            constraint: "check",
-            name: constraintName,
-            expr: build(column),
-        });
-        return this;
-    }
     /**
      * Default constraint name, following Knex's `<table>_<columns>_<suffix>`
      * convention so `unique([...])` and `dropUnique([...])` agree without the
@@ -835,24 +836,24 @@ export class TableBuilder {
             this.#operations.push(op);
             this.#currentOp = op;
         }
-        return this;
+        return new ColumnBuilder(this, col);
     }
     #addFloat(name, type, precision, scale) {
-        this.#addColumn(name, type);
+        const column = this.#addColumn(name, type);
         if (this.#currentColumn) {
             this.#currentColumn.precision = precision;
             this.#currentColumn.scale = scale;
         }
-        return this;
+        return column;
     }
     #addIncrements(name, type) {
-        this.#addColumn(name, type);
+        const column = this.#addColumn(name, type);
         if (this.#currentColumn) {
             this.#currentColumn.autoIncrement = true;
             this.#currentColumn.primary = true;
             this.#currentColumn.nullable = false;
         }
-        return this;
+        return column;
     }
 }
 //# sourceMappingURL=TableBuilder.js.map