@ignisia/sql 0.1.0

package/README.md

@@ -0,0 +1,113 @@
+# @Ignisia/SQL
+
+Type-safe SQL query builder for Bun SQL and SQLite.
+
+## Requirements
+
+- [Bun](https://bun.sh/)
+- [PostgreSQL](https://www.postgresql.org/) (optional, only for PostgreSQL dialect)
+
+## Installation
+
+```bash
+bun add @ignisia/sql
+```
+
+## Usage
+
+```ts
+import { Table, Column, Database } from '@ignisia/sql';
+
+// Define a table
+const users = Table.define(
+  name: 'users',
+  columns: {
+    // Define a column called "id"
+    id: Column.define({
+      type: 'SERIAL',
+    })
+      .primaryKey(),
+    name: Column.define({
+      type: 'TEXT',
+      length: 255,
+    }).notNull(),
+    email: Column.define({
+      type: 'TEXT',
+      length: 255,
+    }).notNull(),
+    password: Column.define({
+      type: 'TEXT',
+      length: 255,
+    }).notNull(),
+  },
+  // Use soft delete, set `paranoid` to `false` to use hard delete
+  // By default the name of the paranoid column called "deletedAt", pass a string to renames it
+  paranoid: true,
+  // Enable timestamps to track created at and updated at, set `timestamp` to `false` to disable timestamp
+  // By default the name of the created at column called "createdAt" and the name of the updated at column called "updatedAt"
+  // Pass an object with `createdAt` and `updatedAt` to rename them
+  timestamp: true,
+);
+
+// Define a database
+const db = Database.define({
+  // Define a connection with PostgreSQL
+  dialect: 'postgres',
+  // Define a PostgreSQL connection
+  config: {
+    host: 'localhost',
+    port: 5432,
+    username: 'postgres',
+    password: 'postgres',
+    database: 'my_database',
+  },
+  // Define tables that connected to the database
+  //  This will automatically assign db properties to each table so it can do query
+  tables: {
+    users,
+  }
+});
+
+// Using the database
+
+// Fetch all users
+const listUsers = await db.table('users').select().query()
+// ^ Add .limit before the .query() to limit the number of results
+// ^ Add .offset before the .query() to offset the results
+// ^ Add .orderBy before the .query() to order the results
+// ^ Add .where before the .query() to filter the results
+// ^ Replace .query() with .toQuery() to know what is the generated query and what are the parameters that will be passed on the query
+
+// Create a new user
+const newUsers = await db.table('users').insert(
+  {
+    name: 'John Doe',
+    email: 'jRZQ3@example.com',
+    password: 'password',
+  },
+  {
+    name: 'Jane Doe',
+    email: 'YKt0x@example.com',
+    password: 'password',
+  }
+);
+
+// Delete a user
+const deletedUsers = await db.table('users').delete()
+// ^ Add .where before the .query() to filter the deleted rows
+
+// Update a user
+const updatedUsers = await db.table('users').update({
+  name: 'John Doe',
+  email: 'jRZQ3@example.com',
+  password: 'password',
+});
+// ^ Add .where before the .query() to filter the updated rows
+```
+
+> Some of the functions is not covered in the usage example above
+> **Note**: `@ignisia/sql` does not do any input validations, therefore it is your responsibility to validate the user input on your own.
+
+## Security Considerations
+
+- For SQLite Dialect, we recommend to use along with the `@ignisia/securedb` package to encrypt/decrypt the database file.

package/dist/chunk-4DQRB5XS.js

@@ -0,0 +1,94 @@
+import {
+  DatabasePsql,
+  DatabaseSqlite
+} from "./chunk-HKTHKQLK.js";
+import {
+  addColumn,
+  dropColumn,
+  renameColumn
+} from "./chunk-JF7OSNH4.js";
+import {
+  createTable,
+  dropTable,
+  renameTable
+} from "./chunk-D2ASIT4Q.js";
+import {
+  alterColumnType,
+  dropColumnDefault,
+  dropColumnNotNull,
+  setColumnDefault
+} from "./chunk-V4OMHVJN.js";
+import {
+  Dialect
+} from "./chunk-GLOHF5CP.js";
+
+// src/database/index.ts
+var Database = class _Database {
+  dialect;
+  defintion;
+  tables;
+  client;
+  createTable;
+  renameTable;
+  dropTable;
+  addColumn;
+  renameColumn;
+  dropColumn;
+  alterColumnType;
+  setColumnDefault;
+  dropColumnDefault;
+  setColumnNotNull;
+  dropColumnNotNull;
+  constructor(options) {
+    this.dialect = options.dialect;
+    this.tables = options.tables ?? {};
+    this.defintion = {
+      dialect: options.dialect,
+      config: options.config
+    };
+    this.client = options.dialect === Dialect.POSTGRES ? new DatabasePsql(options.config) : new DatabaseSqlite(options.config);
+    if (options.tables) {
+      for (const tableName in options.tables) {
+        options.tables[tableName].database = this.client;
+      }
+    }
+    this.createTable = createTable.bind(this);
+    this.renameTable = renameTable.bind(this);
+    this.dropTable = dropTable.bind(this);
+    this.addColumn = addColumn.bind(this);
+    this.renameColumn = renameColumn.bind(this);
+    this.dropColumn = dropColumn.bind(this);
+    this.alterColumnType = alterColumnType.bind(
+      this
+    );
+    this.setColumnDefault = setColumnDefault.bind(
+      this
+    );
+    this.dropColumnDefault = dropColumnDefault.bind(
+      this
+    );
+    this.setColumnNotNull = setColumnDefault.bind(
+      this
+    );
+    this.dropColumnNotNull = dropColumnNotNull.bind(
+      this
+    );
+  }
+  table(tableName) {
+    if (!this.tables[tableName]) {
+      throw new Error(`Table ${tableName} does not exist`);
+    }
+    const table = this.tables[tableName];
+    return table.query();
+  }
+  async transaction(fn) {
+    return this.client.transaction(fn);
+  }
+  static define(options) {
+    return new _Database(options);
+  }
+};
+
+export {
+  Database
+};

package/dist/chunk-CIWX3UCZ.js

@@ -0,0 +1,51 @@
+// 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/chunk-D2ASIT4Q.js

@@ -0,0 +1,44 @@
+import {
+  Table
+} from "./chunk-W2DR3ZVK.js";
+
+// src/database/table.ts
+async function createTable(tableName, columns, options) {
+  const table = Table.define({
+    name: tableName,
+    dialect: this.dialect,
+    columns,
+    ...options
+  });
+  table.database = this.client;
+  this.tables[tableName] = table;
+  if (!this?.client) {
+    throw new Error("Database not connected");
+  }
+  while (this.client.status === "connecting") {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  await table.create(this.client);
+  return this;
+}
+async function renameTable(oldName, newName) {
+  await this.client.exec(`ALTER TABLE ${oldName} RENAME TO ${newName};`);
+  this.tables[newName] = this.tables[oldName];
+  delete this.tables[oldName];
+  return this;
+}
+async function dropTable(tableName) {
+  if (!this.tables[tableName]) {
+    await this.client.exec(`DROP TABLE IF EXISTS ${tableName};`);
+    return this;
+  }
+  await this.tables[tableName].drop(this.client);
+  delete this.tables[tableName];
+  return this;
+}
+
+export {
+  createTable,
+  renameTable,
+  dropTable
+};

package/dist/chunk-FYSNJAGD.js

@@ -0,0 +1,19 @@
+// src/query/join.ts
+function addJoin(query, joinType, alias, joinTable, baseColumn, joinColumn) {
+  if (!query.definition.joins) query.definition.joins = [];
+  query.definition.joins.push(
+    `${joinType} JOIN ${joinTable.name} AS ${alias} ON ${baseColumn} = ${joinColumn}`
+  );
+  if (!query.definition.joinedTables) {
+    query.definition.joinedTables = {};
+  }
+  query.definition.joinedTables = {
+    ...query.definition.joinedTables,
+    [alias]: joinTable
+  };
+  return query;
+}
+
+export {
+  addJoin
+};

package/dist/chunk-G3LSCLIQ.js

@@ -0,0 +1,104 @@
+import {
+  Dialect
+} from "./chunk-GLOHF5CP.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"
+  },
+  [AcceptedColumnTypes.STRING]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "VARCHAR"
+  },
+  [AcceptedColumnTypes.BOOLEAN]: {
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "BOOLEAN"
+  },
+  [AcceptedColumnTypes.DATE]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "DATE"
+  },
+  [AcceptedColumnTypes.FLOAT]: {
+    [Dialect.SQLITE]: "REAL",
+    [Dialect.POSTGRES]: "FLOAT"
+  },
+  [AcceptedColumnTypes.DECIMAL]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "DECIMAL"
+  },
+  [AcceptedColumnTypes.BIGINT]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "BIGINT"
+  },
+  [AcceptedColumnTypes.TEXT]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TEXT"
+  },
+  [AcceptedColumnTypes.BLOB]: {
+    [Dialect.SQLITE]: "BLOB",
+    [Dialect.POSTGRES]: "BYTEA"
+  },
+  [AcceptedColumnTypes.JSON]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "JSONB"
+  },
+  [AcceptedColumnTypes.VARCHAR]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "VARCHAR"
+  },
+  [AcceptedColumnTypes.TIME]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIME"
+  },
+  [AcceptedColumnTypes.TIMESTAMP]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIMESTAMP"
+  },
+  [AcceptedColumnTypes.DOUBLE]: {
+    [Dialect.SQLITE]: "REAL",
+    [Dialect.POSTGRES]: "DOUBLE PRECISION"
+  },
+  [AcceptedColumnTypes.DATETIME]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIMESTAMP"
+  },
+  [AcceptedColumnTypes.DATEONLY]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "DATE"
+  },
+  [AcceptedColumnTypes.ENUM]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TEXT"
+  },
+  [AcceptedColumnTypes.SERIAL]: {
+    [Dialect.SQLITE]: "INTEGER AUTOINCREMENT",
+    [Dialect.POSTGRES]: "SERIAL"
+  }
+};
+
+export {
+  AcceptedColumnTypes,
+  ColumnTypeMapping
+};

package/dist/chunk-GLOHF5CP.js

@@ -0,0 +1,9 @@
+// src/table/constants.ts
+var Dialect = {
+  POSTGRES: "postgres",
+  SQLITE: "sqlite"
+};
+
+export {
+  Dialect
+};

package/dist/chunk-GY7R637S.js

@@ -0,0 +1,113 @@
+import {
+  AcceptedColumnTypes,
+  ColumnTypeMapping
+} from "./chunk-G3LSCLIQ.js";
+import {
+  Dialect
+} from "./chunk-GLOHF5CP.js";
+
+// src/column/index.ts
+var Column = class _Column {
+  definition;
+  type;
+  length;
+  enums;
+  _output;
+  constructor(options) {
+    this.type = options.type;
+    this.enums = [];
+    this.length = null;
+    if ("length" in options) {
+      this.length = options.length;
+    }
+    if ("values" in options) {
+      this.enums = options.values;
+    }
+    this.definition = {
+      autoIncrement: false,
+      primaryKey: false,
+      notNull: false,
+      unique: false,
+      comment: null,
+      default: void 0
+    };
+  }
+  static define(options) {
+    return new _Column(options);
+  }
+  autoIncrement() {
+    this.definition.autoIncrement = true;
+    return this;
+  }
+  primaryKey() {
+    this.definition.primaryKey = true;
+    return this;
+  }
+  notNull() {
+    this.definition.notNull = true;
+    return this;
+  }
+  unique() {
+    this.definition.unique = true;
+    return this;
+  }
+  comment(value) {
+    this.definition.comment = value;
+    return this;
+  }
+  default(value) {
+    this.definition.default = value;
+    return this;
+  }
+  dialect(dialect) {
+    this.definition.dialect = dialect;
+    return this;
+  }
+  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})` : "");
+    if (this.definition.primaryKey) {
+      sql += " PRIMARY KEY";
+    }
+    if (this.definition.autoIncrement || this.type === AcceptedColumnTypes.SERIAL) {
+      const isPrimaryKey = !!this.definition.primaryKey;
+      if (this.definition.dialect === Dialect.POSTGRES) {
+        sql = `SERIAL${isPrimaryKey ? " PRIMARY KEY" : ""}`;
+      } else {
+        if (this.type !== AcceptedColumnTypes.SERIAL) {
+          sql += " AUTOINCREMENT";
+        } else {
+          const sqls = ["INTEGER", "PRIMARY KEY", "AUTOINCREMENT"];
+          if (!isPrimaryKey) sqls.splice(1, 1);
+          sql = sqls.join(" ");
+        }
+      }
+    }
+    if (this.definition.notNull) {
+      sql += " NOT NULL";
+    }
+    if (this.definition.unique) {
+      sql += " 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}`;
+    }
+    return { query: sql, params: [] };
+  }
+  toString() {
+    return this.toQuery().query;
+  }
+  infer() {
+    return null;
+  }
+};
+
+export {
+  Column
+};

package/dist/chunk-HKTHKQLK.js

@@ -0,0 +1,98 @@
+import {
+  Dialect
+} from "./chunk-GLOHF5CP.js";
+
+// src/database/wrapper.ts
+import { SQL } from "bun";
+import { Database as Sqlite } from "bun:sqlite";
+var DatabasePsql = class {
+  dialect;
+  options;
+  client;
+  status;
+  constructor(options) {
+    this.dialect = Dialect.POSTGRES;
+    this.options = options;
+    this.status = "connecting";
+    this.client = new SQL({
+      ...options,
+      onconnect: () => {
+        this.status = "connected";
+      },
+      onclose: () => {
+        this.status = "disconnected";
+      }
+    });
+    this.connect();
+  }
+  async connect() {
+    await this.client.connect();
+    return this;
+  }
+  async disconnect() {
+    await this.client.close();
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async exec(sql, values) {
+    if (!values) {
+      return this.client.unsafe(sql);
+    }
+    return this.client.unsafe(sql, values);
+  }
+  async transaction(fn) {
+    try {
+      await this.exec("BEGIN");
+      const result = await fn();
+      await this.exec("COMMIT");
+      return result;
+    } catch (err) {
+      await this.exec("ROLLBACK");
+      throw err;
+    }
+  }
+};
+var DatabaseSqlite = class {
+  dialect;
+  options;
+  client;
+  status;
+  constructor(options) {
+    this.dialect = Dialect.SQLITE;
+    this.options = options;
+    this.status = "connecting";
+    this.client = new Sqlite(options.filename);
+    this.status = "connected";
+  }
+  async connect() {
+    this.client = new Sqlite(this.options.filename);
+    this.status = "connected";
+    return this;
+  }
+  async disconnect() {
+    this.client.close();
+    this.status = "disconnected";
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async exec(sql, params) {
+    const query = this.client.prepare(sql, params);
+    return query.all();
+  }
+  async transaction(fn) {
+    try {
+      await this.exec("BEGIN");
+      const result = await fn();
+      await this.exec("COMMIT");
+      return result;
+    } catch (err) {
+      await this.exec("ROLLBACK");
+      throw err;
+    }
+  }
+};
+
+export {
+  DatabasePsql,
+  DatabaseSqlite
+};

package/dist/chunk-JF7OSNH4.js

@@ -0,0 +1,40 @@
+import {
+  Dialect
+} from "./chunk-GLOHF5CP.js";
+
+// src/database/column.ts
+async function addColumn(tableName, columnName, column) {
+  await this.client.exec(
+    `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${column.toString()};`
+  );
+  if (!this.tables[tableName]) return this;
+  this.tables[tableName].columns[columnName] = column;
+  return this;
+}
+async function renameColumn(tableName, oldName, newName) {
+  if (this.dialect === Dialect.SQLITE) {
+    throw new Error("SQLite does not support RENAME COLUMN natively.");
+  }
+  await this.client.exec(
+    `ALTER TABLE ${tableName} RENAME COLUMN ${oldName} TO ${newName};`
+  );
+  if (!this.tables[tableName]) return this;
+  this.tables[tableName].columns[newName] = this.tables[tableName].columns[oldName];
+  delete this.tables[tableName].columns[oldName];
+  return this;
+}
+async function dropColumn(tableName, columnName) {
+  if (this.dialect === Dialect.SQLITE) {
+    throw new Error("SQLite does not support DROP COLUMN natively.");
+  }
+  await this.client.exec(`ALTER TABLE ${tableName} DROP COLUMN ${columnName};`);
+  if (!this.tables[tableName]) return this;
+  delete this.tables[tableName].columns[columnName];
+  return this;
+}
+
+export {
+  addColumn,
+  renameColumn,
+  dropColumn
+};