@ignisia/sql 0.2.2 → 0.3.0

package/dist/esm/query/index.js

@@ -153,22 +153,31 @@ var QueryBuilder = class {
   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

package/dist/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/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/esm/query/sql.js

@@ -1,3 +1,4 @@
+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';
@@ -10,7 +11,7 @@ function buildQuery(query) {
     return `$${index}`;
   });
 }
-function toQuery() {
+function toQuery(dialect) {
   let sql = "";
   switch (this.definition.queryType) {
     case QueryType.SELECT:
@@ -56,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 };
@@ -64,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

@@ -1,7 +1,8 @@
 import '../column/index.js';
 import '../column/constants.js';
-export { j as AcceptedInsertValues, i as AcceptedOrderBy, k as AcceptedUpdateValues, l as AggregateColumn, A as AliasedColumn, C as ColumnSelector, f as QuerHooks, Q as QueryDefinition, n as QueryOutput, h as QueryRunHooks, o as QueryRunHooksOptions, R as RawColumn, m as SelectQueryOutput, e as SelectableColumn, c as StrictColumnSelector, W as WhereValue } from '../index-FMT0YEO7.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/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/esm/query/utilities.js

@@ -61,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/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/esm/table/constants.js

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

package/dist/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';

package/dist/esm/table/index.js

@@ -4,22 +4,21 @@ import { defineColumns } from './utilities.js';
 // src/table/index.ts
 var Table = class _Table {
   client;
-  dialect;
+  _dialect;
   name;
   columns;
   timestamp;
   paranoid;
   _output;
   constructor(options) {
-    this.dialect = options.dialect;
+    this._dialect = options.dialect || null;
     this.name = options.name;
     this.columns = options.columns;
     this.paranoid = options.paranoid || null;
     this.timestamp = options.timestamp || null;
     this.client = null;
-    for (const column of Object.values(this.columns)) {
-      column.dialect(options.dialect);
-    }
+    if (!this._dialect) return;
+    this.setColumnDialect(this._dialect);
   }
   infer() {
     return null;
@@ -31,18 +30,39 @@ var Table = class _Table {
       columns
     });
   }
-  async create(db = this.client) {
+  setColumnDialect(dialect) {
+    for (const column of Object.values(this.columns)) {
+      column.dialect(dialect);
+    }
+  }
+  get dialect() {
+    return this._dialect;
+  }
+  setDialect(dialect) {
+    this._dialect = dialect;
+    this.setColumnDialect(dialect);
+    return this;
+  }
+  async create(options = {}) {
+    const db = options.db || this.client;
     if (!db) throw new Error("Database client not defined");
     const sql = `CREATE TABLE IF NOT EXISTS ${this.name} (${Object.entries(
       this.columns
     ).map(([name, column]) => `${name} ${column.toQuery().query}`).join(", ")});`;
-    await db.exec(sql);
+    await db.exec({
+      sql,
+      tx: options.tx
+    });
     return this;
   }
-  async drop(db = this.client) {
+  async drop(options = {}) {
+    const db = options.db || this.client;
     if (!db) throw new Error("Database client not defined");
     const sql = `DROP TABLE IF EXISTS ${this.name};`;
-    await db.exec(sql);
+    await db.exec({
+      sql,
+      tx: options.tx
+    });
     return this;
   }
   query() {

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

@@ -1,4 +1,5 @@
-export { M as MergeTimestampParanoid, s as TableOptions, t as TableOutput, a as TimestampOptions } from '../index-FMT0YEO7.js';
+import 'bun';
+export { E as ExecOptions, M as MergeTimestampParanoid, x as TableOptions, y as TableOutput, a as TimestampOptions } from '../index-BdpoD4zk.js';
 import '../column/index.js';
 import './constants.js';
 import '../column/constants.js';

package/dist/esm/table/utilities.d.ts

@@ -1,7 +1,8 @@
 import '../column/constants.js';
 import '../column/index.js';
 import './constants.js';
-export { p as createdAt, r as defineColumns, q as deletedAt, u as updatedAt } from '../index-FMT0YEO7.js';
+export { t as createdAt, w as defineColumns, v as deletedAt, u as updatedAt } from '../index-BdpoD4zk.js';
 import '../column/types.js';
 import '../types.js';
 import '../query/constants.js';
+import 'bun';

package/package.json

@@ -3,7 +3,7 @@
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "type": "module",
   "exports": {
     ".": {