@ignisia/sql 0.2.2 → 0.3.0

package/dist/cjs/query/condition.d.cts

@@ -1,7 +1,8 @@
-export { H as addCondition, B as addRawCondition, K as having, J as or, G as rawHaving, F as rawOr, E as rawWhere, I as where } from '../index-CwiFQh0I.cjs';
+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-CnQVnCEI.cjs';
 import '../column/index.cjs';
 import './constants.cjs';
 import '../column/constants.cjs';
 import '../types.cjs';
+import 'bun';
 import '../table/constants.cjs';
 import '../column/types.cjs';

package/dist/cjs/query/condition.js

@@ -49,6 +49,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 = utilities.getCondition(query.table.dialect, column, operator, value);
   if (!query.definition[validClause]) query.definition[validClause] = [];
@@ -71,7 +74,7 @@ function where(column, operator, value) {
     constants.ConditionClause.WHERE,
     column,
     operator,
-    value,
+    value || null,
     constants.LogicalOperator.AND
   );
 }
@@ -81,7 +84,7 @@ function or(column, operator, value) {
     constants.ConditionClause.WHERE,
     column,
     operator,
-    value,
+    value || null,
     constants.LogicalOperator.OR
   );
 }

package/dist/cjs/query/contract.d.cts

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

package/dist/cjs/query/helper.d.cts

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

package/dist/cjs/query/index.d.cts

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

package/dist/cjs/query/index.js

@@ -154,22 +154,31 @@ class QueryBuilder {
   insert(...values) {
     this.definition.queryType = constants.QueryType.INSERT;
     if (!this.definition.insertValues) this.definition.insertValues = [];
-    const { isWithTimestamp, createdAt, updatedAt, timestamp } = utilities$1.getTimestamp(
-      this.table
-    );
+    const {
+      isWithTimestamp,
+      isHasCreatedAt,
+      isHasUpdatedAt,
+      createdAt,
+      updatedAt,
+      timestamp
+    } = utilities$1.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 } = utilities$1.getTimestamp(this.table);
-    if (isWithTimestamp) {
+    const { isWithTimestamp, isHasUpdatedAt, updatedAt, timestamp } = utilities$1.getTimestamp(this.table);
+    if (isWithTimestamp && isHasUpdatedAt) {
       values = {
         ...values,
         [updatedAt]: values[updatedAt] ?? timestamp

package/dist/cjs/query/join.d.cts

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

package/dist/cjs/query/sql.d.cts

@@ -1,17 +1,18 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-CwiFQh0I.cjs';
+import { TransactionSQL } from 'bun';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-CnQVnCEI.cjs';
 import { Column } from '../column/index.cjs';
+import { Dialect } from '../table/constants.cjs';
 import '../column/constants.cjs';
 import '../types.cjs';
 import './constants.cjs';
-import '../table/constants.cjs';
 import '../column/types.cjs';
 
 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/cjs/query/sql.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var constants$1 = require('../table/constants');
 var builder = require('./builder');
 var constants = require('./constants');
 var utilities = require('./utilities');
@@ -11,7 +12,7 @@ function buildQuery(query) {
     return `$${index}`;
   });
 }
-function toQuery() {
+function toQuery(dialect) {
   let sql = "";
   switch (this.definition.queryType) {
     case constants.QueryType.SELECT:
@@ -57,7 +58,9 @@ function toQuery() {
     this.definition.params.push(this.definition.offset);
   }
   if (this.definition.queryType === constants.QueryType.UPDATE || this.definition.queryType === constants.QueryType.DELETE) {
-    sql += ` RETURNING *`;
+    if (dialect !== constants$1.Dialect.MYSQL) {
+      sql += ` RETURNING *`;
+    }
   }
   sql = buildQuery(sql);
   return { query: sql + ";", params: this.definition.params };
@@ -65,26 +68,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 === constants.QueryType.UPDATE;
+  const isDelete = queryType === constants.QueryType.DELETE;
+  const isReturning = isUpdate || isDelete;
+  const isMySQL = dialect === constants$1.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: constants.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 = constants.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: constants.QueryHooksType.AFTER
       });
     }

package/dist/cjs/query/types.d.cts

@@ -1,7 +1,8 @@
 import '../column/index.cjs';
 import '../column/constants.cjs';
-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-CwiFQh0I.cjs';
+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-CnQVnCEI.cjs';
 import '../types.cjs';
 import './constants.cjs';
 import '../table/constants.cjs';
 import '../column/types.cjs';
+import 'bun';

package/dist/cjs/query/utilities.d.cts

@@ -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-CwiFQh0I.cjs';
+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-CnQVnCEI.cjs';
 import { Column } from '../column/index.cjs';
 import { Dialect } from '../table/constants.cjs';
 import { AcceptedOperator } from './constants.cjs';
 import '../column/constants.cjs';
 import '../types.cjs';
+import 'bun';
 import '../column/types.cjs';
 
 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/cjs/query/utilities.js

@@ -62,22 +62,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/cjs/table/constants.d.cts

@@ -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/cjs/table/constants.js

@@ -2,6 +2,7 @@
 
 const Dialect = {
   POSTGRES: "postgres",
+  MYSQL: "mysql",
   SQLITE: "sqlite"
 };
 

package/dist/cjs/table/index.d.cts

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

package/dist/cjs/table/index.js

@@ -5,22 +5,21 @@ var utilities = require('./utilities');
 
 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;
@@ -32,18 +31,39 @@ 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/cjs/table/types.d.cts

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

package/dist/cjs/table/utilities.d.cts

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

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

@@ -23,75 +23,128 @@ declare const ColumnTypeMapping: {
     readonly INTEGER: {
         readonly sqlite: "INTEGER";
         readonly postgres: "INTEGER";
+        readonly mysql: "INT";
     };
     readonly STRING: {
         readonly sqlite: "TEXT";
         readonly postgres: "VARCHAR";
+        readonly mysql: "VARCHAR";
     };
     readonly BOOLEAN: {
         readonly sqlite: "INTEGER";
         readonly postgres: "BOOLEAN";
+        readonly mysql: "TINYINT";
     };
     readonly DATE: {
         readonly sqlite: "TEXT";
         readonly postgres: "DATE";
+        readonly mysql: "DATE";
     };
     readonly FLOAT: {
         readonly sqlite: "REAL";
         readonly postgres: "FLOAT";
+        readonly mysql: "FLOAT PRECISION";
     };
     readonly DECIMAL: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "NUMERIC";
         readonly postgres: "DECIMAL";
+        readonly mysql: "DECIMAL";
     };
     readonly BIGINT: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "INTEGER";
         readonly postgres: "BIGINT";
+        readonly mysql: "BIGINT";
     };
     readonly TEXT: {
         readonly sqlite: "TEXT";
         readonly postgres: "TEXT";
+        readonly mysql: "TEXT";
     };
     readonly BLOB: {
         readonly sqlite: "BLOB";
         readonly postgres: "BYTEA";
+        readonly mysql: "BLOB";
     };
     readonly JSON: {
         readonly sqlite: "TEXT";
         readonly postgres: "JSONB";
+        readonly mysql: "JSON";
     };
     readonly VARCHAR: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "VARCHAR";
         readonly postgres: "VARCHAR";
+        readonly mysql: "VARCHAR";
     };
     readonly TIME: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIME";
+        readonly mysql: "TIME";
     };
     readonly TIMESTAMP: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIMESTAMP";
+        readonly mysql: "DATETIME";
     };
     readonly DOUBLE: {
         readonly sqlite: "REAL";
         readonly postgres: "DOUBLE PRECISION";
+        readonly mysql: "DOUBLE PRECISION";
     };
     readonly DATETIME: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIMESTAMP";
+        readonly mysql: "DATETIME";
     };
     readonly DATEONLY: {
         readonly sqlite: "TEXT";
         readonly postgres: "DATE";
+        readonly mysql: "DATE";
     };
     readonly ENUM: {
         readonly sqlite: "TEXT";
         readonly postgres: "TEXT";
+        readonly mysql: "TEXT";
     };
     readonly SERIAL: {
-        readonly sqlite: "INTEGER AUTOINCREMENT";
+        readonly sqlite: "INTEGER";
         readonly postgres: "SERIAL";
+        readonly mysql: "INT";
+    };
+};
+declare const ColumnProperties: {
+    readonly NOT_NULL: "NOT_NULL";
+    readonly UNIQUE: "UNIQUE";
+    readonly DEFAULT: "DEFAULT";
+    readonly AUTO_INCREMENT: "AUTO_INCREMENT";
+    readonly PRIMARY_KEY: "PRIMARY_KEY";
+};
+type ColumnProperties = (typeof ColumnProperties)[keyof typeof ColumnProperties];
+declare const ColumnPropertyMapping: {
+    NOT_NULL: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    UNIQUE: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    DEFAULT: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    AUTO_INCREMENT: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    PRIMARY_KEY: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
     };
 };
 
-export { AcceptedColumnTypes, ColumnTypeMapping };
+export { AcceptedColumnTypes, ColumnProperties, ColumnPropertyMapping, ColumnTypeMapping };