@ignisia/sql 0.2.1 → 0.3.0

package/dist/{column → 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 };

package/dist/esm/column/constants.js

@@ -0,0 +1,154 @@
+import { Dialect } from '../table/constants.js';
+
+// src/column/constants.ts
+var AcceptedColumnTypes = {
+  INTEGER: "INTEGER",
+  STRING: "STRING",
+  BOOLEAN: "BOOLEAN",
+  DATE: "DATE",
+  FLOAT: "FLOAT",
+  DECIMAL: "DECIMAL",
+  BIGINT: "BIGINT",
+  TEXT: "TEXT",
+  BLOB: "BLOB",
+  JSON: "JSON",
+  VARCHAR: "VARCHAR",
+  TIME: "TIME",
+  TIMESTAMP: "TIMESTAMP",
+  DOUBLE: "DOUBLE",
+  DATETIME: "DATETIME",
+  DATEONLY: "DATEONLY",
+  ENUM: "ENUM",
+  SERIAL: "SERIAL"
+};
+var ColumnTypeMapping = {
+  [AcceptedColumnTypes.INTEGER]: {
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "INTEGER",
+    [Dialect.MYSQL]: "INT"
+  },
+  [AcceptedColumnTypes.STRING]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "VARCHAR",
+    [Dialect.MYSQL]: "VARCHAR"
+  },
+  [AcceptedColumnTypes.BOOLEAN]: {
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "BOOLEAN",
+    [Dialect.MYSQL]: "TINYINT"
+  },
+  [AcceptedColumnTypes.DATE]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "DATE",
+    [Dialect.MYSQL]: "DATE"
+  },
+  [AcceptedColumnTypes.FLOAT]: {
+    [Dialect.SQLITE]: "REAL",
+    [Dialect.POSTGRES]: "FLOAT",
+    [Dialect.MYSQL]: "FLOAT PRECISION"
+  },
+  [AcceptedColumnTypes.DECIMAL]: {
+    [Dialect.SQLITE]: "NUMERIC",
+    [Dialect.POSTGRES]: "DECIMAL",
+    [Dialect.MYSQL]: "DECIMAL"
+  },
+  [AcceptedColumnTypes.BIGINT]: {
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "BIGINT",
+    [Dialect.MYSQL]: "BIGINT"
+  },
+  [AcceptedColumnTypes.TEXT]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TEXT",
+    [Dialect.MYSQL]: "TEXT"
+  },
+  [AcceptedColumnTypes.BLOB]: {
+    [Dialect.SQLITE]: "BLOB",
+    [Dialect.POSTGRES]: "BYTEA",
+    [Dialect.MYSQL]: "BLOB"
+  },
+  [AcceptedColumnTypes.JSON]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "JSONB",
+    [Dialect.MYSQL]: "JSON"
+  },
+  [AcceptedColumnTypes.VARCHAR]: {
+    [Dialect.SQLITE]: "VARCHAR",
+    [Dialect.POSTGRES]: "VARCHAR",
+    [Dialect.MYSQL]: "VARCHAR"
+  },
+  [AcceptedColumnTypes.TIME]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIME",
+    [Dialect.MYSQL]: "TIME"
+  },
+  [AcceptedColumnTypes.TIMESTAMP]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIMESTAMP",
+    [Dialect.MYSQL]: "DATETIME"
+  },
+  [AcceptedColumnTypes.DOUBLE]: {
+    [Dialect.SQLITE]: "REAL",
+    [Dialect.POSTGRES]: "DOUBLE PRECISION",
+    [Dialect.MYSQL]: "DOUBLE PRECISION"
+  },
+  [AcceptedColumnTypes.DATETIME]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIMESTAMP",
+    [Dialect.MYSQL]: "DATETIME"
+  },
+  [AcceptedColumnTypes.DATEONLY]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "DATE",
+    [Dialect.MYSQL]: "DATE"
+  },
+  [AcceptedColumnTypes.ENUM]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TEXT",
+    [Dialect.MYSQL]: "TEXT"
+  },
+  [AcceptedColumnTypes.SERIAL]: {
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "SERIAL",
+    [Dialect.MYSQL]: "INT"
+  }
+};
+var ColumnProperties = {
+  NOT_NULL: "NOT_NULL",
+  UNIQUE: "UNIQUE",
+  DEFAULT: "DEFAULT",
+  AUTO_INCREMENT: "AUTO_INCREMENT",
+  PRIMARY_KEY: "PRIMARY_KEY"
+};
+var ColumnPropertyMapping = {
+  [ColumnProperties.NOT_NULL]: {
+    [Dialect.SQLITE]: "NOT NULL",
+    [Dialect.POSTGRES]: "NOT NULL",
+    [Dialect.MYSQL]: "NOT NULL"
+  },
+  [ColumnProperties.UNIQUE]: {
+    [Dialect.SQLITE]: "UNIQUE",
+    [Dialect.POSTGRES]: "UNIQUE",
+    [Dialect.MYSQL]: "UNIQUE"
+  },
+  [ColumnProperties.DEFAULT]: {
+    [Dialect.SQLITE]: "DEFAULT",
+    [Dialect.POSTGRES]: "DEFAULT",
+    [Dialect.MYSQL]: "DEFAULT"
+  },
+  [ColumnProperties.AUTO_INCREMENT]: {
+    // sqlite does not support AUTOINCREMENT
+    [Dialect.SQLITE]: "AUTOINCREMENT",
+    // postgres does not support AUTOINCREMENT
+    [Dialect.POSTGRES]: "AUTOINCREMENT",
+    // Exists only for mysql since mysql supports AUTOINCREMENT
+    [Dialect.MYSQL]: "AUTO_INCREMENT"
+  },
+  [ColumnProperties.PRIMARY_KEY]: {
+    [Dialect.SQLITE]: "PRIMARY KEY",
+    [Dialect.POSTGRES]: "PRIMARY KEY",
+    [Dialect.MYSQL]: "PRIMARY KEY"
+  }
+};
+
+export { AcceptedColumnTypes, ColumnProperties, ColumnPropertyMapping, ColumnTypeMapping };

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

@@ -31,6 +31,7 @@ declare class Column<Type extends AcceptedColumnTypes = AcceptedColumnTypes, Val
     dialect<DbDialect extends Dialect>(dialect: DbDialect): Column<Type, Values, Options, ColumnValue, Value, Definition & {
         dialect: DbDialect;
     }>;
+    clone(): Column<Type, Values, Options, ColumnValue, Value, {}>;
     toQuery(): {
         query: string;
         params: never[];

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

@@ -1,7 +1,10 @@
-import { Dialect } from '../table/constants';
-import { ColumnTypeMapping, AcceptedColumnTypes } from './constants';
+import { Dialect } from '../table/constants.js';
+import { deepClone } from '../utilities.js';
+import { ColumnTypeMapping, AcceptedColumnTypes } from './constants.js';
+import { columnProperty } from './utils.js';
 
-class Column {
+// src/column/index.ts
+var Column = class _Column {
   definition;
   type;
   length;
@@ -27,7 +30,7 @@ class Column {
     };
   }
   static define(options) {
-    return new Column(options);
+    return new _Column(options);
   }
   autoIncrement() {
     this.definition.autoIncrement = true;
@@ -57,40 +60,58 @@ class Column {
     this.definition.dialect = dialect;
     return this;
   }
+  clone() {
+    const column = new _Column({
+      type: this.type,
+      ...this.length && { length: this.length },
+      ...this.enums.length && { values: this.enums }
+    });
+    Object.assign(column.definition, deepClone(this.definition));
+    return column;
+  }
   toQuery() {
     if (!this.definition.dialect) {
       throw new Error("No DB Dialect defined");
     }
-    const correctType = ColumnTypeMapping[this.type][this.definition.dialect];
-    let sql = correctType + (this.length ? `(${this.length})` : "");
+    const type = ColumnTypeMapping[this.type][this.definition.dialect];
+    const properties = columnProperty(this.definition.dialect);
+    let sql = type + (this.length ? `(${this.length})` : "");
     if (this.definition.primaryKey) {
-      sql += " PRIMARY KEY";
+      sql += ` ${properties.PRIMARY_KEY}`;
     }
     if (this.definition.autoIncrement || this.type === AcceptedColumnTypes.SERIAL) {
       const isPrimaryKey = !!this.definition.primaryKey;
+      const sqls = [];
       if (this.definition.dialect === Dialect.POSTGRES) {
-        sql = `SERIAL${isPrimaryKey ? " PRIMARY KEY" : ""}`;
+        sqls.push(type);
+        if (isPrimaryKey) {
+          sqls.push(properties.PRIMARY_KEY);
+        }
+        sql = sqls.join(" ");
       } else {
         if (this.type !== AcceptedColumnTypes.SERIAL) {
-          sql += " AUTOINCREMENT";
+          sql += ` ${properties.AUTO_INCREMENT}`;
         } else {
-          const sqls = ["INTEGER", "PRIMARY KEY", "AUTOINCREMENT"];
-          if (!isPrimaryKey) sqls.splice(1, 1);
+          sqls.push(type);
+          if (isPrimaryKey) {
+            sqls.push(properties.PRIMARY_KEY);
+          }
+          sqls.push(properties.AUTO_INCREMENT);
           sql = sqls.join(" ");
         }
       }
     }
     if (this.definition.notNull) {
-      sql += " NOT NULL";
+      sql += ` ${properties.NOT_NULL}`;
     }
     if (this.definition.unique) {
-      sql += " UNIQUE";
+      sql += ` ${properties.UNIQUE}`;
     }
     if (this.definition.default !== void 0) {
       const value = this.definition.default;
       const isString = typeof this.definition.default === "string";
       const finalValue = isString ? `'${value}'` : value;
-      sql += ` DEFAULT ${finalValue}`;
+      sql += ` ${properties.DEFAULT} ${finalValue}`;
     }
     return { query: sql, params: [] };
   }
@@ -100,6 +121,6 @@ class Column {
   infer() {
     return null;
   }
-}
+};
 
 export { Column };

package/dist/esm/column/types.js

@@ -0,0 +1 @@
+import './constants.js';

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

@@ -0,0 +1,133 @@
+import { Dialect } from '../table/constants.js';
+import { ColumnProperties } from './constants.js';
+
+declare function getColumnProperty<DbDialect extends Dialect>(dialect: DbDialect, property: ColumnProperties): ({
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+})[DbDialect];
+declare function columnProperty<DbDialect extends Dialect>(dialect: DbDialect): {
+    NOT_NULL: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    UNIQUE: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    DEFAULT: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    AUTO_INCREMENT: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    PRIMARY_KEY: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+};
+
+export { columnProperty, getColumnProperty };

package/dist/esm/column/utils.js

@@ -0,0 +1,32 @@
+import { ColumnPropertyMapping, ColumnProperties } from './constants.js';
+
+// src/column/utils.ts
+function getColumnProperty(dialect, property) {
+  return ColumnPropertyMapping[property][dialect];
+}
+function columnProperty(dialect) {
+  return {
+    [ColumnProperties.NOT_NULL]: getColumnProperty(
+      dialect,
+      ColumnProperties.NOT_NULL
+    ),
+    [ColumnProperties.UNIQUE]: getColumnProperty(
+      dialect,
+      ColumnProperties.UNIQUE
+    ),
+    [ColumnProperties.DEFAULT]: getColumnProperty(
+      dialect,
+      ColumnProperties.DEFAULT
+    ),
+    [ColumnProperties.AUTO_INCREMENT]: getColumnProperty(
+      dialect,
+      ColumnProperties.AUTO_INCREMENT
+    ),
+    [ColumnProperties.PRIMARY_KEY]: getColumnProperty(
+      dialect,
+      ColumnProperties.PRIMARY_KEY
+    )
+  };
+}
+
+export { columnProperty, getColumnProperty };

package/dist/{database → esm/database}/alter.d.ts

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

package/dist/{database → esm/database}/alter.js

@@ -1,12 +1,13 @@
-import { Dialect } from '../table/constants';
+import { Dialect } from '../table/constants.js';
 
+// src/database/alter.ts
 async function alterColumnType(tableName, columnName, newType) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support ALTER COLUMN TYPE directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType}`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType}`
+  });
   if (!this.tables[tableName]) return this;
   this.tables[tableName].columns[columnName].type = newType;
   return this;
@@ -15,9 +16,9 @@ async function setColumnDefault(tableName, columnName, value) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support ALTER COLUMN DEFAULT directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${value}`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${value}`
+  });
   if (!this.tables[tableName]) return this;
   if (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -32,9 +33,9 @@ async function dropColumnDefault(tableName, columnName) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support DROP DEFAULT directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT`
+  });
   if (!this.tables[tableName]) return this;
   if (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -51,9 +52,9 @@ async function setColumnNotNull(tableName, columnName) {
       "SQLite does not support SET NOT NULL (requires table rebuild)"
     );
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL`
+  });
   if (!this.tables[tableName]) return this;
   if (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -70,9 +71,9 @@ async function dropColumnNotNull(tableName, columnName) {
       "SQLite does not support DROP NOT NULL (requires table rebuild)"
     );
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL`
+  });
   if (!this.tables[tableName]) return this;
   if (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/{database → esm/database}/column.d.ts

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