@ignisia/sql 0.2.0 → 0.2.2

package/dist/cjs/database/table.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var table = require('../table');
+
+async function createTable(tableName, columns, options) {
+  const table$1 = table.Table.define({
+    name: tableName,
+    dialect: this.dialect,
+    columns,
+    ...options
+  });
+  table$1.client = this.client;
+  this.tables[tableName] = table$1;
+  if (!this?.client) {
+    throw new Error("Database not connected");
+  }
+  while (this.client.status === "connecting") {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  await table$1.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;
+}
+
+exports.createTable = createTable;
+exports.dropTable = dropTable;
+exports.renameTable = renameTable;

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

@@ -0,0 +1,7 @@
+import '../column/index.cjs';
+export { D as DatabaseDefinition, b as DatabaseDialect, g as DatabaseOptions, P as PostgresConfig, S as SqliteConfig } from '../index-CwiFQh0I.cjs';
+import '../table/constants.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+import '../query/constants.cjs';

package/dist/cjs/database/types.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/cjs/database/wrapper.d.cts

@@ -0,0 +1,36 @@
+import { SQL } from 'bun';
+import { Database } from 'bun:sqlite';
+import { Dialect } from '../table/constants.cjs';
+import { b as DatabaseDialect, P as PostgresConfig, S as SqliteConfig } from '../index-CwiFQh0I.cjs';
+import '../column/index.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+import '../query/constants.cjs';
+
+declare class DatabasePsql implements DatabaseDialect {
+    readonly dialect: typeof Dialect.POSTGRES;
+    readonly options: PostgresConfig;
+    client: SQL;
+    status: 'connecting' | 'connected' | 'disconnected';
+    constructor(options: PostgresConfig);
+    connect(): Promise<this>;
+    disconnect(): Promise<this>;
+    exec<T>(sql: string): Promise<T>;
+    exec<T>(sql: string, values: any[]): Promise<T>;
+    transaction<T, U extends () => Promise<T>>(fn: U): Promise<T>;
+}
+declare class DatabaseSqlite implements DatabaseDialect {
+    readonly dialect: typeof Dialect.SQLITE;
+    readonly options: SqliteConfig;
+    client: Database;
+    status: 'connecting' | 'connected' | 'disconnected';
+    constructor(options: SqliteConfig);
+    connect(): Promise<this>;
+    disconnect(): Promise<this>;
+    exec<T>(sql: string): Promise<T>;
+    exec<T>(sql: string, params: any): Promise<T>;
+    transaction<T, U extends () => Promise<T>>(fn: U): Promise<T>;
+}
+
+export { DatabasePsql, DatabaseSqlite };

package/dist/cjs/database/wrapper.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var bun = require('bun');
+var bun_sqlite = require('bun:sqlite');
+var constants = require('../table/constants');
+
+class DatabasePsql {
+  dialect;
+  options;
+  client;
+  status;
+  constructor(options) {
+    this.dialect = constants.Dialect.POSTGRES;
+    this.options = options;
+    this.status = "connecting";
+    this.client = new bun.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;
+    }
+  }
+}
+class DatabaseSqlite {
+  dialect;
+  options;
+  client;
+  status;
+  constructor(options) {
+    this.dialect = constants.Dialect.SQLITE;
+    this.options = options;
+    this.status = "connecting";
+    this.client = new bun_sqlite.Database(options.filename);
+    this.status = "connected";
+  }
+  async connect() {
+    this.client = new bun_sqlite.Database(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;
+    }
+  }
+}
+
+exports.DatabasePsql = DatabasePsql;
+exports.DatabaseSqlite = DatabaseSqlite;

package/dist/cjs/index---zaMa69.d.cts

@@ -0,0 +1,103 @@
+import { Column } from './column/index.cjs';
+import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid, f as QuerHooks, b as DatabaseDialect, g as DatabaseOptions, d as QueryBuilder, h as QueryRunHooks } from './index-CwiFQh0I.cjs';
+import { QueryHooksType } from './query/constants.cjs';
+import { Dialect } from './table/constants.cjs';
+import { AcceptedColumnTypes } from './column/constants.cjs';
+
+interface TableAlterationContract<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>> = DatabaseDefinition<DbDialect>> {
+    createTable<TableName extends string, Columns extends Record<string, Column>, CreatedAt extends string, UpdatedAt extends string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean, FinalColumns extends MergeTimestampParanoid<Columns, CreatedAt, UpdatedAt, Timestamp, Paranoid>, NewTables extends Tables & {
+        [K in TableName]: Table<TableName, FinalColumns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>;
+    }>(tableName: TableName, columns: Columns, options?: {
+        paranoid?: Paranoid;
+        timestamp?: Timestamp;
+    }): Promise<Database<DbDialect, NewTables, Definition>>;
+    renameTable<OldName extends (keyof Tables & string) | (string & {}), NewName extends string, NewTables extends Omit<Tables, OldName> & {
+        [K in NewName]: Tables[OldName];
+    }>(oldName: OldName, newName: NewName): Promise<Database<DbDialect, NewTables, Omit<Definition, 'tables'> & {
+        tables: NewTables;
+    }>>;
+    dropTable<TableName extends (keyof Tables & string) | (string & {})>(tableName: TableName): Promise<Database<DbDialect, Omit<Tables, TableName>, Definition>>;
+}
+interface ColumnAlterationContract<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>> = DatabaseDefinition<DbDialect>> {
+    addColumn<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Tables[TableName]['columns'] & {
+            [K in ColName]: Column;
+        }>;
+    }>(tableName: TableName, columnName: ColName, column: Column): Promise<Database<DbDialect, NewTables, Definition>>;
+    renameColumn<TableName extends (keyof Tables & string) | (string & {}), OldName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], OldName> & {
+            [K in NewName]: Tables[TableName]['columns'][OldName];
+        }>;
+    }>(tableName: TableName, oldName: OldName, newName: NewName): Promise<Database<DbDialect, NewTables, Definition>>;
+    dropColumn<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName>>;
+    }>(tableName: TableName, columnName: ColName): Promise<Database<DbDialect, NewTables, Definition>>;
+    alterColumnType<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), Type extends Omit<AcceptedColumnTypes, typeof AcceptedColumnTypes.ENUM>, NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Tables[TableName]['columns'][ColName] & {
+                type: Type;
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName, newType: Type): Promise<Database<DbDialect, NewTables, Definition>>;
+    setColumnDefault<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), DefaultValue extends string | number | boolean | null, NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+                definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'default'> & {
+                    default: DefaultValue;
+                };
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName, value: DefaultValue): Promise<Database<DbDialect, NewTables, Definition>>;
+    dropColumnDefault<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+                definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'default'> & {
+                    default: undefined;
+                };
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName): Promise<Database<DbDialect, NewTables, Definition>>;
+    setColumnNotNull<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+                definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'notNull'> & {
+                    notNull: true;
+                };
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName): Promise<Database<DbDialect, NewTables, Definition>>;
+    dropColumnNotNull<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+                definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'notNull'>;
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName): Promise<Database<DbDialect, NewTables, Definition>>;
+}
+
+declare class Database<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>> = DatabaseDefinition<DbDialect>> {
+    readonly hooks: Partial<QuerHooks>;
+    readonly dialect: DbDialect;
+    readonly defintion: Definition;
+    readonly tables: Tables;
+    readonly client: DatabaseDialect;
+    createTable: TableAlterationContract<DbDialect, Tables, Definition>['createTable'];
+    renameTable: TableAlterationContract<DbDialect, Tables, Definition>['renameTable'];
+    dropTable: TableAlterationContract<DbDialect, Tables, Definition>['dropTable'];
+    addColumn: ColumnAlterationContract<DbDialect, Tables, Definition>['addColumn'];
+    renameColumn: ColumnAlterationContract<DbDialect, Tables, Definition>['renameColumn'];
+    dropColumn: ColumnAlterationContract<DbDialect, Tables, Definition>['dropColumn'];
+    alterColumnType: ColumnAlterationContract<DbDialect, Tables, Definition>['alterColumnType'];
+    setColumnDefault: ColumnAlterationContract<DbDialect, Tables, Definition>['setColumnDefault'];
+    dropColumnDefault: ColumnAlterationContract<DbDialect, Tables, Definition>['dropColumnDefault'];
+    setColumnNotNull: ColumnAlterationContract<DbDialect, Tables, Definition>['setColumnNotNull'];
+    dropColumnNotNull: ColumnAlterationContract<DbDialect, Tables, Definition>['dropColumnNotNull'];
+    protected constructor(options: DatabaseOptions<DbDialect, Tables>);
+    table<TableName extends keyof Tables & string, Table extends Tables[TableName]>(tableName: TableName): QueryBuilder<TableName, Table>;
+    addHook(type: QueryHooksType, fn: QueryRunHooks): this;
+    removeHook(type: QueryHooksType, fn: QueryRunHooks): this;
+    transaction<T, U extends () => Promise<T>>(fn: U): Promise<unknown>;
+    static define<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>>(options: DatabaseOptions<DbDialect, Tables>): Database<DbDialect, Tables, DatabaseDefinition<DbDialect>>;
+}
+
+export { type ColumnAlterationContract as C, Database as D, type TableAlterationContract as T };