@ignisia/sql 0.2.1 → 0.3.0

package/dist/esm/migration/index.js

@@ -0,0 +1,49 @@
+// src/migration/index.ts
+var Migration = class _Migration {
+  db;
+  _up;
+  _down;
+  constructor(options) {
+    this.db = options.db;
+    this._up = options.up;
+    this._down = options.down;
+  }
+  get up() {
+    return this._up;
+  }
+  get down() {
+    return this._down;
+  }
+  static setUp(migrator, fn) {
+    migrator._up = () => fn(migrator.db);
+    return migrator;
+  }
+  static setDown(migrator, fn) {
+    migrator._down = () => fn(migrator.db);
+    return migrator;
+  }
+  static define(db, options) {
+    const migration = new _Migration({
+      db,
+      up: options?.up ? () => options.up(db) : null,
+      down: options?.down ? () => options.down(db) : null
+    });
+    return {
+      migration,
+      setUp(fn) {
+        return _Migration.setUp(
+          migration,
+          fn
+        );
+      },
+      setDown(fn) {
+        return _Migration.setDown(
+          migration,
+          fn
+        );
+      }
+    };
+  }
+};
+
+export { Migration };

package/dist/esm/migration/runner.d.ts

@@ -0,0 +1,3 @@
+declare function runMigration(filePath: string, direction: 'up' | 'down'): Promise<void>;
+
+export { runMigration };

package/dist/{migration → esm/migration}/runner.js

@@ -1,14 +1,15 @@
-import { Column } from '../column';
-import { Table } from '../table';
+import { Column } from '../column/index.js';
+import { Table } from '../table/index.js';
 
-const nameColumn = Column.define({
+// src/migration/runner.ts
+var nameColumn = Column.define({
   type: "TEXT",
   length: 255
 }).primaryKey().notNull();
-const runAtColumn = Column.define({
+var runAtColumn = Column.define({
   type: "DATETIME"
 }).notNull();
-let migrationTable = null;
+var migrationTable = null;
 async function runMigration(filePath, direction) {
   const migrationFile = await import(filePath);
   const fileName = filePath.split("/").pop();
@@ -28,7 +29,7 @@ async function runMigration(filePath, direction) {
       dialect: migration.db.dialect
     });
     migrationTable.client = migration.db.client;
-    await migrationTable.create();
+    await migrationTable.create({});
   }
   const fn = migration[direction];
   if (!fn)

package/dist/{migration → esm/migration}/type.d.ts

@@ -1,9 +1,10 @@
 import { Column } from '../column/index.js';
-import { D as Database } from '../index-DFrpzXEn.js';
-import { T as Table } from '../index-FMT0YEO7.js';
+import { D as Database } from '../index-BXOAxB_h.js';
+import { T as Table } from '../index-BdpoD4zk.js';
 import { Dialect } from '../table/constants.js';
 import '../column/constants.js';
 import '../column/types.js';
+import 'bun';
 import '../query/constants.js';
 import '../types.js';
 

package/dist/{query → esm/query}/builder.d.ts

@@ -1,8 +1,9 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-FMT0YEO7.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-BdpoD4zk.js';
 import { Column } from '../column/index.js';
 import '../column/constants.js';
 import '../types.js';
 import './constants.js';
+import 'bun';
 import '../table/constants.js';
 import '../column/types.js';
 

package/dist/{query → esm/query}/builder.js

@@ -1,6 +1,7 @@
-import { quoteIdentifier } from '../utilities';
-import { getTableSelectName } from './utilities';
+import { quoteIdentifier } from '../utilities.js';
+import { getTableSelectName } from './utilities.js';
 
+// src/query/builder.ts
 function buildSelectQuery(q) {
   const from = getTableSelectName(q);
   const columns = [];

package/dist/esm/query/condition.d.ts

@@ -0,0 +1,8 @@
+export { N as addCondition, I as addRawCondition, V as having, U as or, L as rawHaving, K as rawOr, J as rawWhere, O as where } from '../index-BdpoD4zk.js';
+import '../column/index.js';
+import './constants.js';
+import '../column/constants.js';
+import '../types.js';
+import 'bun';
+import '../table/constants.js';
+import '../column/types.js';

package/dist/{query → esm/query}/condition.js

@@ -1,7 +1,8 @@
-import { LogicalOperator, ConditionClause, AcceptedOperator } from './constants';
-import { rawCol } from './helper';
-import { getCondition } from './utilities';
+import { LogicalOperator, ConditionClause, AcceptedOperator } from './constants.js';
+import { rawCol } from './helper.js';
+import { getCondition } from './utilities.js';
 
+// src/query/condition.ts
 function addRawCondition(query, clause, column, logical, params) {
   const validClause = clause.toLowerCase();
   if (!query.definition[validClause]) query.definition[validClause] = [];
@@ -47,6 +48,9 @@ function rawHaving(column, params) {
   );
 }
 function addCondition(query, clause, column, operator, value, logical) {
+  if (!query.table.dialect) {
+    throw new Error("No DB Dialect defined");
+  }
   const validClause = clause.toLowerCase();
   const condition = getCondition(query.table.dialect, column, operator, value);
   if (!query.definition[validClause]) query.definition[validClause] = [];
@@ -69,7 +73,7 @@ function where(column, operator, value) {
     ConditionClause.WHERE,
     column,
     operator,
-    value,
+    value || null,
     LogicalOperator.AND
   );
 }
@@ -79,7 +83,7 @@ function or(column, operator, value) {
     ConditionClause.WHERE,
     column,
     operator,
-    value,
+    value || null,
     LogicalOperator.OR
   );
 }

package/dist/esm/query/constants.d.ts

@@ -0,0 +1,63 @@
+declare const LogicalOperator: {
+    readonly AND: "AND";
+    readonly OR: "OR";
+};
+type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
+declare const ConditionClause: {
+    readonly WHERE: "WHERE";
+    readonly HAVING: "HAVING";
+};
+type ConditionClause = (typeof ConditionClause)[keyof typeof ConditionClause];
+declare const AcceptedOperator: {
+    readonly EQ: "eq";
+    readonly NE: "ne";
+    readonly GT: "gt";
+    readonly LT: "lt";
+    readonly GTE: "gte";
+    readonly LTE: "lte";
+    readonly IN: "in";
+    readonly NOT_IN: "notIn";
+    readonly LIKE: "like";
+    readonly NOT_LIKE: "notLike";
+    readonly ILIKE: "ilike";
+    readonly NOT_ILIKE: "notILike";
+    readonly IS_NULL: "isNull";
+    readonly IS_NOT_NULL: "isNotNull";
+    readonly BETWEEN: "between";
+    readonly NOT_BETWEEN: "notBetween";
+};
+type AcceptedOperator = (typeof AcceptedOperator)[keyof typeof AcceptedOperator];
+declare const QueryType: {
+    readonly SELECT: "SELECT";
+    readonly INSERT: "INSERT";
+    readonly UPDATE: "UPDATE";
+    readonly DELETE: "DELETE";
+};
+type QueryType = (typeof QueryType)[keyof typeof QueryType];
+declare const OrderBy: {
+    readonly ASC: "ASC";
+    readonly DESC: "DESC";
+};
+type OrderBy = (typeof OrderBy)[keyof typeof OrderBy];
+declare const AggregationFunction: {
+    readonly COUNT: "COUNT";
+    readonly SUM: "SUM";
+    readonly MIN: "MIN";
+    readonly MAX: "MAX";
+    readonly AVG: "AVG";
+};
+type AggregationFunction = (typeof AggregationFunction)[keyof typeof AggregationFunction];
+declare const AcceptedJoin: {
+    readonly INNER: "INNER";
+    readonly LEFT: "LEFT";
+    readonly RIGHT: "RIGHT";
+    readonly NATURAL: "NATURAL";
+};
+type AcceptedJoin = (typeof AcceptedJoin)[keyof typeof AcceptedJoin];
+declare const QueryHooksType: {
+    readonly AFTER: "after";
+    readonly BEFORE: "before";
+};
+type QueryHooksType = (typeof QueryHooksType)[keyof typeof QueryHooksType];
+
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };

package/dist/{query → esm/query}/constants.js

@@ -1,12 +1,13 @@
-const LogicalOperator = {
+// src/query/constants.ts
+var LogicalOperator = {
   AND: "AND",
   OR: "OR"
 };
-const ConditionClause = {
+var ConditionClause = {
   WHERE: "WHERE",
   HAVING: "HAVING"
 };
-const AcceptedOperator = {
+var AcceptedOperator = {
   EQ: "eq",
   NE: "ne",
   GT: "gt",
@@ -24,30 +25,30 @@ const AcceptedOperator = {
   BETWEEN: "between",
   NOT_BETWEEN: "notBetween"
 };
-const QueryType = {
+var QueryType = {
   SELECT: "SELECT",
   INSERT: "INSERT",
   UPDATE: "UPDATE",
   DELETE: "DELETE"
 };
-const OrderBy = {
+var OrderBy = {
   ASC: "ASC",
   DESC: "DESC"
 };
-const AggregationFunction = {
+var AggregationFunction = {
   COUNT: "COUNT",
   SUM: "SUM",
   MIN: "MIN",
   MAX: "MAX",
   AVG: "AVG"
 };
-const AcceptedJoin = {
+var AcceptedJoin = {
   INNER: "INNER",
   LEFT: "LEFT",
   RIGHT: "RIGHT",
   NATURAL: "NATURAL"
 };
-const QueryHooksType = {
+var QueryHooksType = {
   AFTER: "after",
   BEFORE: "before"
 };

package/dist/{query → esm/query}/contract.d.ts

@@ -1,7 +1,8 @@
-export { N as QueryConditionContract, L as QueryTransformerContract } from '../index-FMT0YEO7.js';
+import 'bun';
+export { Y as QueryConditionContract, X as QueryTransformerContract } from '../index-BdpoD4zk.js';
 import '../column/index.js';
+import '../table/constants.js';
 import './constants.js';
 import '../column/constants.js';
 import '../types.js';
-import '../table/constants.js';
 import '../column/types.js';

package/dist/{query → esm/query}/helper.d.ts

@@ -1,7 +1,8 @@
-export { z as aggregateCol, v as alias, w as clone, y as col, x as rawCol } from '../index-FMT0YEO7.js';
+export { H as aggregateCol, z as alias, B as clone, G as col, F as rawCol } from '../index-BdpoD4zk.js';
 import '../column/index.js';
 import './constants.js';
 import '../column/constants.js';
 import '../types.js';
+import 'bun';
 import '../table/constants.js';
 import '../column/types.js';

package/dist/{query → esm/query}/helper.js

@@ -1,6 +1,7 @@
-import { QueryBuilder } from '.';
-import { deepClone } from '../utilities';
+import { QueryBuilder } from './index.js';
+import { deepClone } from '../utilities.js';
 
+// src/query/helper.ts
 function alias(alias2) {
   this.definition.baseAlias = alias2;
   return this;

package/dist/{query → esm/query}/index.d.ts

@@ -1,7 +1,8 @@
 import '../column/index.js';
-export { d as QueryBuilder } from '../index-FMT0YEO7.js';
+export { f as QueryBuilder } from '../index-BdpoD4zk.js';
 import './constants.js';
 import '../table/constants.js';
 import '../column/constants.js';
 import '../column/types.js';
 import '../types.js';
+import 'bun';

package/dist/{query → esm/query}/index.js

@@ -1,12 +1,13 @@
-import { quoteIdentifier } from '../utilities';
-import { rawWhere, rawHaving, rawOr, where, having, or } from './condition';
-import { AcceptedJoin, QueryType } from './constants';
-import { alias, clone, aggregateCol, col } from './helper';
-import { addJoin } from './join';
-import { toQuery, toString, exec } from './sql';
-import { getTimestamp, getParanoid } from './utilities';
+import { quoteIdentifier } from '../utilities.js';
+import { rawWhere, rawHaving, rawOr, where, having, or } from './condition.js';
+import { AcceptedJoin, QueryType } from './constants.js';
+import { alias, clone, aggregateCol, col } from './helper.js';
+import { addJoin } from './join.js';
+import { toQuery, toString, exec } from './sql.js';
+import { getTimestamp, getParanoid } from './utilities.js';
 
-class QueryBuilder {
+// src/query/index.ts
+var QueryBuilder = class {
   hooks;
   table;
   definition;
@@ -152,22 +153,31 @@ class QueryBuilder {
   insert(...values) {
     this.definition.queryType = QueryType.INSERT;
     if (!this.definition.insertValues) this.definition.insertValues = [];
-    const { isWithTimestamp, createdAt, updatedAt, timestamp } = getTimestamp(
-      this.table
-    );
+    const {
+      isWithTimestamp,
+      isHasCreatedAt,
+      isHasUpdatedAt,
+      createdAt,
+      updatedAt,
+      timestamp
+    } = getTimestamp(this.table);
     if (isWithTimestamp) {
       values = values.map((row) => ({
         ...row,
-        [createdAt]: row[createdAt] ?? timestamp,
-        [updatedAt]: row[updatedAt] ?? timestamp
+        ...isHasCreatedAt && {
+          [createdAt]: row[createdAt] ?? timestamp
+        },
+        ...isHasUpdatedAt && {
+          [updatedAt]: row[updatedAt] ?? timestamp
+        }
       }));
     }
     this.definition.insertValues = values;
     return this;
   }
   update(values) {
-    const { isWithTimestamp, updatedAt, timestamp } = getTimestamp(this.table);
-    if (isWithTimestamp) {
+    const { isWithTimestamp, isHasUpdatedAt, updatedAt, timestamp } = getTimestamp(this.table);
+    if (isWithTimestamp && isHasUpdatedAt) {
       values = {
         ...values,
         [updatedAt]: values[updatedAt] ?? timestamp
@@ -190,6 +200,6 @@ class QueryBuilder {
   infer() {
     return null;
   }
-}
+};
 
 export { QueryBuilder };

package/dist/{query → esm/query}/join.d.ts

@@ -1,8 +1,9 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-FMT0YEO7.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-BdpoD4zk.js';
 import { Column } from '../column/index.js';
 import { AcceptedJoin } from './constants.js';
 import '../column/constants.js';
 import '../types.js';
+import 'bun';
 import '../table/constants.js';
 import '../column/types.js';
 

package/dist/{query → esm/query}/join.js

@@ -1,3 +1,4 @@
+// src/query/join.ts
 function addJoin(query, joinType, alias, joinTable, baseColumn, joinColumn) {
   if (!query.definition.joins) query.definition.joins = [];
   query.definition.joins.push(

package/dist/{query → esm/query}/sql.d.ts

@@ -1,17 +1,18 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-FMT0YEO7.js';
+import { TransactionSQL } from 'bun';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-BdpoD4zk.js';
 import { Column } from '../column/index.js';
+import { Dialect } from '../table/constants.js';
 import '../column/constants.js';
 import '../types.js';
 import './constants.js';
-import '../table/constants.js';
 import '../column/types.js';
 
 declare function buildQuery(query: string): string;
-declare function toQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query): {
+declare function toQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query, dialect?: Dialect | null): {
     query: string;
     params: unknown[] | null | undefined;
 };
 declare function toString<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query): string;
-declare function exec<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, Output extends Query['_output'] = Query['_output']>(this: Query): Promise<Output>;
+declare function exec<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, Output extends Query['_output'] = Query['_output']>(this: Query, tx?: TransactionSQL | null): Promise<Output>;
 
 export { buildQuery, exec, toQuery, toString };

package/dist/{query → esm/query}/sql.js

@@ -1,7 +1,9 @@
-import { buildDeleteQuery, buildUpdateQuery, buildInsertQuery, buildSelectQuery } from './builder';
-import { QueryType, QueryHooksType } from './constants';
-import { getWhereConditions, getGroupByConditions, parseAliasedRow } from './utilities';
+import { Dialect } from '../table/constants.js';
+import { buildDeleteQuery, buildUpdateQuery, buildInsertQuery, buildSelectQuery } from './builder.js';
+import { QueryType, QueryHooksType } from './constants.js';
+import { getWhereConditions, getGroupByConditions, parseAliasedRow } from './utilities.js';
 
+// src/query/sql.ts
 function buildQuery(query) {
   let index = 0;
   return query.replace(/\?/g, () => {
@@ -9,7 +11,7 @@ function buildQuery(query) {
     return `$${index}`;
   });
 }
-function toQuery() {
+function toQuery(dialect) {
   let sql = "";
   switch (this.definition.queryType) {
     case QueryType.SELECT:
@@ -55,7 +57,9 @@ function toQuery() {
     this.definition.params.push(this.definition.offset);
   }
   if (this.definition.queryType === QueryType.UPDATE || this.definition.queryType === QueryType.DELETE) {
-    sql += ` RETURNING *`;
+    if (dialect !== Dialect.MYSQL) {
+      sql += ` RETURNING *`;
+    }
   }
   sql = buildQuery(sql);
   return { query: sql + ";", params: this.definition.params };
@@ -63,26 +67,51 @@ function toQuery() {
 function toString() {
   return this.toQuery().query;
 }
-async function exec() {
-  if (!this.table.client) throw new Error("Database client not defined");
-  const { query, params } = this.toQuery();
+async function exec(tx) {
+  const client = this.table.client;
+  const dialect = this.table.dialect;
+  const queryType = this.definition.queryType;
+  const isUpdate = queryType === QueryType.UPDATE;
+  const isDelete = queryType === QueryType.DELETE;
+  const isReturning = isUpdate || isDelete;
+  const isMySQL = dialect === Dialect.MYSQL;
+  if (!client) {
+    throw new Error("Database client not defined");
+  }
+  if (!queryType) {
+    throw new Error("No query type defined");
+  }
+  const { query, params } = this.toQuery(dialect);
   if (this.hooks?.before?.size) {
     for (const hook of this.hooks.before.values()) {
       hook({
         query,
         params,
-        type: this.definition.queryType,
+        type: queryType,
         hook: QueryHooksType.BEFORE
       });
     }
   }
-  const result = await this.table.client.exec(query, params);
+  let result = await client.exec({
+    sql: query,
+    params,
+    tx
+  });
+  if (isMySQL && isReturning) {
+    const query2 = this.clone();
+    query2.definition.queryType = QueryType.SELECT;
+    result = await client.exec({
+      sql: query2.toQuery().query,
+      params,
+      tx
+    });
+  }
   if (this.hooks?.after?.size) {
     for (const hook of this.hooks.after.values()) {
       hook({
         query,
         params,
-        type: this.definition.queryType,
+        type: queryType,
         hook: QueryHooksType.AFTER
       });
     }

package/dist/esm/query/types.d.ts

@@ -0,0 +1,8 @@
+import '../column/index.js';
+import '../column/constants.js';
+export { l as AcceptedInsertValues, k as AcceptedOrderBy, m as AcceptedUpdateValues, n as AggregateColumn, A as AliasedColumn, C as ColumnSelector, h as QuerHooks, Q as QueryDefinition, p as QueryOutput, j as QueryRunHooks, q as QueryRunHooksOptions, R as RawColumn, o as SelectQueryOutput, g as SelectableColumn, e as StrictColumnSelector, W as WhereValue } from '../index-BdpoD4zk.js';
+import '../types.js';
+import './constants.js';
+import '../table/constants.js';
+import '../column/types.js';
+import 'bun';

package/dist/{query → esm/query}/utilities.d.ts

@@ -1,9 +1,10 @@
-import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder, A as AliasedColumn, e as SelectableColumn } from '../index-FMT0YEO7.js';
+import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder, A as AliasedColumn, g as SelectableColumn } from '../index-BdpoD4zk.js';
 import { Column } from '../column/index.js';
 import { Dialect } from '../table/constants.js';
 import { AcceptedOperator } from './constants.js';
 import '../column/constants.js';
 import '../types.js';
+import 'bun';
 import '../column/types.js';
 
 declare function getTableColumnNames<ColName extends string, BaseAlias extends string, BaseTable extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>>(column: ColName, baseAlias: BaseAlias, baseTable: BaseTable, joinedTables: JoinedTables): {
@@ -16,6 +17,8 @@ declare function getTimestamp<TableRef extends Table<string, Record<string, Colu
     timestamp: Date;
     createdAt: string;
     updatedAt: string;
+    isHasUpdatedAt: boolean;
+    isHasCreatedAt: boolean;
 };
 declare function getParanoid<TableRef extends Table<string, Record<string, Column>>>(table: TableRef): {
     isWithParanoid: boolean;

package/dist/{query → esm/query}/utilities.js

@@ -1,8 +1,9 @@
-import '.';
-import { Dialect } from '../table/constants';
-import { quoteIdentifier } from '../utilities';
-import { AcceptedOperator, QueryType } from './constants';
+import './index.js';
+import { Dialect } from '../table/constants.js';
+import { quoteIdentifier } from '../utilities.js';
+import { AcceptedOperator, QueryType } from './constants.js';
 
+// src/query/utilities.ts
 function getTableColumnNames(column, baseAlias, baseTable, joinedTables) {
   const [tableAlias] = column.split(".");
   const isOnBase = tableAlias === baseAlias;
@@ -60,22 +61,32 @@ function getCondition(dialect, column, operator, value) {
 function getTimestamp(table) {
   const isWithTimestamp = !!table.timestamp;
   const timestamp = /* @__PURE__ */ new Date();
+  let isHasCreatedAt = true;
+  let isHasUpdatedAt = true;
   let createdAt = "createdAt";
   let updatedAt = "updatedAt";
   if (isWithTimestamp) {
     const isCustomTimestamp = typeof table.timestamp === "object";
-    if (isCustomTimestamp && table.timestamp.createdAt) {
-      createdAt = table.timestamp.createdAt;
+    if (isCustomTimestamp) {
+      if (typeof table.timestamp.createdAt === "string") {
+        createdAt = table.timestamp.createdAt;
+      }
+      isHasCreatedAt = table.timestamp.createdAt === false;
     }
-    if (isCustomTimestamp && table.timestamp.updatedAt) {
-      updatedAt = table.timestamp.updatedAt;
+    if (isCustomTimestamp) {
+      if (typeof table.timestamp.updatedAt === "string") {
+        updatedAt = table.timestamp.updatedAt;
+      }
+      isHasUpdatedAt = table.timestamp.updatedAt === false;
     }
   }
   return {
     isWithTimestamp,
     timestamp,
     createdAt,
-    updatedAt
+    updatedAt,
+    isHasUpdatedAt,
+    isHasCreatedAt
   };
 }
 function getParanoid(table) {

package/dist/{table → esm/table}/constants.d.ts

@@ -1,5 +1,6 @@
 declare const Dialect: {
     readonly POSTGRES: "postgres";
+    readonly MYSQL: "mysql";
     readonly SQLITE: "sqlite";
 };
 type Dialect = (typeof Dialect)[keyof typeof Dialect];

package/dist/{table → esm/table}/constants.js

@@ -1,5 +1,7 @@
-const Dialect = {
+// src/table/constants.ts
+var Dialect = {
   POSTGRES: "postgres",
+  MYSQL: "mysql",
   SQLITE: "sqlite"
 };
 

package/dist/{table → esm/table}/index.d.ts

@@ -1,7 +1,8 @@
-export { T as Table } from '../index-FMT0YEO7.js';
+export { T as Table } from '../index-BdpoD4zk.js';
 import '../column/index.js';
 import './constants.js';
 import '../column/constants.js';
 import '../types.js';
 import '../query/constants.js';
+import 'bun';
 import '../column/types.js';