workers-qb 1.6.7 → 1.8.0

package/README.md

@@ -19,12 +19,13 @@ Currently, 3 databases are supported:
 
 ## Features
 
-- [x] Zero dependencies.
+- [x] Zero dependencies
 - [x] Fully typed/TypeScript support
+- [x] [Migrations](https://workers-qb.massadas.com/migrations/)
 - [x] [Type Checks for data read](https://workers-qb.massadas.com/type-check/)
 - [x] [Create/drop tables](https://workers-qb.massadas.com/basic-queries/#dropping-and-creating-tables)
 - [x] [Insert/Bulk Inserts/Update/Select/Delete/Join queries](https://workers-qb.massadas.com/basic-queries/)
-- [x] [Modular selects](https://workers-qb.massadas.com/modular-selects/)
+- [x] [Modular selects](https://workers-qb.massadas.com/modular-selects/) (qb.select(...).where(...).where(...).one())
 - [x] [On Conflict for Inserts and Updates](https://workers-qb.massadas.com/advanced-queries/onConflict/)
 - [x] [Upsert](https://workers-qb.massadas.com/advanced-queries/upsert/)
 
@@ -40,7 +41,7 @@ npm install workers-qb --save
 import { D1QB } from 'workers-qb'
 
 export interface Env {
-  DB: any
+  DB: D1Database
 }
 
 export default {
@@ -65,7 +66,7 @@ export default {
       .execute()
 
     // Or in a modular approach
-    const employeeList = await qb.select<Employee>('employees').where('active = ?', true).execute()
+    const employeeListModular = await qb.select<Employee>('employees').where('active = ?', true).execute()
 
     // You get IDE type hints on each employee data, like:
     // employeeList.results[0].name
@@ -77,6 +78,26 @@ export default {
 }
 ```
 
+## Example for Cloudflare Durable Objects
+
+```ts
+import { DOQB } from 'workers-qb'
+
+export class DOSRS extends DurableObject {
+  getEmployees() {
+    const qb = new DOQB(this.ctx.storage.sql)
+
+    const fetched = qb
+      .fetchAll({
+        tableName: 'employees',
+      })
+      .execute()
+
+    return fetched.results
+  }
+}
+```
+
 ## Example for Cloudflare Workers with PostgreSQL
 
 Remember to close the connection using `ctx.waitUntil(qb.close());` or `await qb.close();` at the end of your request.

package/dist/index.d.mts

@@ -178,6 +178,10 @@ type AsyncType<T> = Promise<T>;
 type SyncType<T> = T;
 type MaybeAsync<IsAsync extends boolean, T> = IsAsync extends true ? AsyncType<T> : SyncType<T>;
 
+declare function defaultLogger(query: RawQuery, meta: QueryLoggerMeta): any;
+declare function asyncLoggerWrapper<Async extends boolean = true>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): Promise<any>;
+declare function syncLoggerWrapper<Async extends boolean = false>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): any;
+
 declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnObject, IsAsync extends boolean = true> {
     _debugger: boolean;
     _options: Partial<SelectAll>;
@@ -188,6 +192,7 @@ declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnO
     tableName(tableName: SelectAll['tableName']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     fields(fields: SelectAll['fields']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     where(conditions: string | Array<string>, params?: Primitive | Primitive[]): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
+    whereIn<T extends string | Array<string>, P extends T extends Array<string> ? Primitive[][] : Primitive[]>(fields: T, values: P): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     join(join: SelectAll['join']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     groupBy(groupBy: SelectAll['groupBy']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     having(having: SelectAll['having']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
@@ -203,10 +208,6 @@ declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnO
     count(): MaybeAsync<IsAsync, CountResult<GenericResultWrapper>>;
 }
 
-declare function defaultLogger(query: RawQuery, meta: QueryLoggerMeta): any;
-declare function asyncLoggerWrapper<Async extends boolean = true>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): Promise<any>;
-declare function syncLoggerWrapper<Async extends boolean = false>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): any;
-
 declare class QueryBuilder<GenericResultWrapper, IsAsync extends boolean = true> {
     protected options: QueryBuilderOptions<IsAsync>;
     loggerWrapper: typeof asyncLoggerWrapper;
@@ -253,16 +254,53 @@ declare class QueryBuilder<GenericResultWrapper, IsAsync extends boolean = true>
     protected _returning(value?: string | Array<string>): string;
 }
 
+type MigrationEntry = {
+    id: number;
+    name: string;
+    applied_at: Date;
+};
+type Migration = {
+    name: string;
+    sql: string;
+};
+type MigrationOptions = {
+    migrations: Array<Migration>;
+    tableName?: string;
+};
+declare class syncMigrationsBuilder<GenericResultWrapper> {
+    _builder: QueryBuilder<GenericResultWrapper, false>;
+    _migrations: Array<Migration>;
+    _tableName: string;
+    constructor(options: MigrationOptions, builder: QueryBuilder<GenericResultWrapper, false>);
+    initialize(): void;
+    getApplied(): Array<MigrationEntry>;
+    getUnapplied(): Array<Migration>;
+    apply(): Array<Migration>;
+}
+declare class asyncMigrationsBuilder<GenericResultWrapper> {
+    _builder: QueryBuilder<GenericResultWrapper, true>;
+    _migrations: Array<Migration>;
+    _tableName: string;
+    constructor(options: MigrationOptions, builder: QueryBuilder<GenericResultWrapper, true>);
+    initialize(): Promise<void>;
+    getApplied(): Promise<Array<MigrationEntry>>;
+    getUnapplied(): Promise<Array<Migration>>;
+    apply(): Promise<Array<Migration>>;
+}
+
 declare class D1QB extends QueryBuilder<D1Result> {
     db: any;
     constructor(db: any, options?: QueryBuilderOptions);
+    migrations(options: MigrationOptions): asyncMigrationsBuilder<D1Result>;
     execute(query: Query): Promise<any>;
     batchExecute(queryArray: Query[]): Promise<any>;
 }
 
 declare class PGQB extends QueryBuilder<PGResult> {
     db: any;
+    _migrationsBuilder: typeof asyncMigrationsBuilder;
     constructor(db: any, options?: QueryBuilderOptions);
+    migrations(options: MigrationOptions): asyncMigrationsBuilder<PGResult>;
     connect(): Promise<void>;
     close(): Promise<void>;
     execute(query: Query): Promise<any>;
@@ -272,7 +310,8 @@ declare class DOQB extends QueryBuilder<{}, false> {
     db: any;
     loggerWrapper: typeof syncLoggerWrapper;
     constructor(db: any, options?: QueryBuilderOptions<false>);
+    migrations(options: MigrationOptions): syncMigrationsBuilder<{}>;
     execute(query: Query<any, false>): any;
 }
 
-export { type ArrayResult, type AsyncType, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type Join, JoinTypes, type MaybeAsync, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, type QueryBuilderOptions, type QueryLoggerMeta, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type SyncType, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, asyncLoggerWrapper, defaultLogger, syncLoggerWrapper, type test, trimQuery };
+export { type ArrayResult, type AsyncType, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type Join, JoinTypes, type MaybeAsync, type Migration, type MigrationEntry, type MigrationOptions, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, type QueryBuilderOptions, type QueryLoggerMeta, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type SyncType, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, asyncLoggerWrapper, asyncMigrationsBuilder, defaultLogger, syncLoggerWrapper, syncMigrationsBuilder, type test, trimQuery };

package/dist/index.d.ts

@@ -178,6 +178,10 @@ type AsyncType<T> = Promise<T>;
 type SyncType<T> = T;
 type MaybeAsync<IsAsync extends boolean, T> = IsAsync extends true ? AsyncType<T> : SyncType<T>;
 
+declare function defaultLogger(query: RawQuery, meta: QueryLoggerMeta): any;
+declare function asyncLoggerWrapper<Async extends boolean = true>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): Promise<any>;
+declare function syncLoggerWrapper<Async extends boolean = false>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): any;
+
 declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnObject, IsAsync extends boolean = true> {
     _debugger: boolean;
     _options: Partial<SelectAll>;
@@ -188,6 +192,7 @@ declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnO
     tableName(tableName: SelectAll['tableName']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     fields(fields: SelectAll['fields']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     where(conditions: string | Array<string>, params?: Primitive | Primitive[]): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
+    whereIn<T extends string | Array<string>, P extends T extends Array<string> ? Primitive[][] : Primitive[]>(fields: T, values: P): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     join(join: SelectAll['join']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     groupBy(groupBy: SelectAll['groupBy']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
     having(having: SelectAll['having']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
@@ -203,10 +208,6 @@ declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnO
     count(): MaybeAsync<IsAsync, CountResult<GenericResultWrapper>>;
 }
 
-declare function defaultLogger(query: RawQuery, meta: QueryLoggerMeta): any;
-declare function asyncLoggerWrapper<Async extends boolean = true>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): Promise<any>;
-declare function syncLoggerWrapper<Async extends boolean = false>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): any;
-
 declare class QueryBuilder<GenericResultWrapper, IsAsync extends boolean = true> {
     protected options: QueryBuilderOptions<IsAsync>;
     loggerWrapper: typeof asyncLoggerWrapper;
@@ -253,16 +254,53 @@ declare class QueryBuilder<GenericResultWrapper, IsAsync extends boolean = true>
     protected _returning(value?: string | Array<string>): string;
 }
 
+type MigrationEntry = {
+    id: number;
+    name: string;
+    applied_at: Date;
+};
+type Migration = {
+    name: string;
+    sql: string;
+};
+type MigrationOptions = {
+    migrations: Array<Migration>;
+    tableName?: string;
+};
+declare class syncMigrationsBuilder<GenericResultWrapper> {
+    _builder: QueryBuilder<GenericResultWrapper, false>;
+    _migrations: Array<Migration>;
+    _tableName: string;
+    constructor(options: MigrationOptions, builder: QueryBuilder<GenericResultWrapper, false>);
+    initialize(): void;
+    getApplied(): Array<MigrationEntry>;
+    getUnapplied(): Array<Migration>;
+    apply(): Array<Migration>;
+}
+declare class asyncMigrationsBuilder<GenericResultWrapper> {
+    _builder: QueryBuilder<GenericResultWrapper, true>;
+    _migrations: Array<Migration>;
+    _tableName: string;
+    constructor(options: MigrationOptions, builder: QueryBuilder<GenericResultWrapper, true>);
+    initialize(): Promise<void>;
+    getApplied(): Promise<Array<MigrationEntry>>;
+    getUnapplied(): Promise<Array<Migration>>;
+    apply(): Promise<Array<Migration>>;
+}
+
 declare class D1QB extends QueryBuilder<D1Result> {
     db: any;
     constructor(db: any, options?: QueryBuilderOptions);
+    migrations(options: MigrationOptions): asyncMigrationsBuilder<D1Result>;
     execute(query: Query): Promise<any>;
     batchExecute(queryArray: Query[]): Promise<any>;
 }
 
 declare class PGQB extends QueryBuilder<PGResult> {
     db: any;
+    _migrationsBuilder: typeof asyncMigrationsBuilder;
     constructor(db: any, options?: QueryBuilderOptions);
+    migrations(options: MigrationOptions): asyncMigrationsBuilder<PGResult>;
     connect(): Promise<void>;
     close(): Promise<void>;
     execute(query: Query): Promise<any>;
@@ -272,7 +310,8 @@ declare class DOQB extends QueryBuilder<{}, false> {
     db: any;
     loggerWrapper: typeof syncLoggerWrapper;
     constructor(db: any, options?: QueryBuilderOptions<false>);
+    migrations(options: MigrationOptions): syncMigrationsBuilder<{}>;
     execute(query: Query<any, false>): any;
 }
 
-export { type ArrayResult, type AsyncType, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type Join, JoinTypes, type MaybeAsync, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, type QueryBuilderOptions, type QueryLoggerMeta, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type SyncType, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, asyncLoggerWrapper, defaultLogger, syncLoggerWrapper, type test, trimQuery };
+export { type ArrayResult, type AsyncType, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type Join, JoinTypes, type MaybeAsync, type Migration, type MigrationEntry, type MigrationOptions, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, type QueryBuilderOptions, type QueryLoggerMeta, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type SyncType, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, asyncLoggerWrapper, asyncMigrationsBuilder, defaultLogger, syncLoggerWrapper, syncMigrationsBuilder, type test, trimQuery };

package/dist/index.js

@@ -32,8 +32,10 @@ __export(src_exports, {
   QueryWithExtra: () => QueryWithExtra,
   Raw: () => Raw,
   asyncLoggerWrapper: () => asyncLoggerWrapper,
+  asyncMigrationsBuilder: () => asyncMigrationsBuilder,
   defaultLogger: () => defaultLogger,
   syncLoggerWrapper: () => syncLoggerWrapper,
+  syncMigrationsBuilder: () => syncMigrationsBuilder,
   trimQuery: () => trimQuery
 });
 module.exports = __toCommonJS(src_exports);
@@ -64,50 +66,45 @@ var JoinTypes = /* @__PURE__ */ ((JoinTypes2) => {
   return JoinTypes2;
 })(JoinTypes || {});
 
-// src/tools.ts
-var Raw = class {
-  isRaw = true;
-  content;
-  constructor(content) {
-    this.content = content;
-  }
-};
-var Query = class {
-  executeMethod;
-  query;
-  arguments;
-  fetchType;
-  constructor(executeMethod, query, args, fetchType) {
-    this.executeMethod = executeMethod;
-    this.query = trimQuery(query);
-    this.arguments = args;
-    this.fetchType = fetchType;
-  }
-  execute() {
-    return this.executeMethod(this);
-  }
-  toObject() {
-    return {
-      query: this.query,
-      args: this.arguments,
-      fetchType: this.fetchType
-    };
-  }
-};
-var QueryWithExtra = class extends Query {
-  countQuery;
-  constructor(executeMethod, query, countQuery, args, fetchType) {
-    super(executeMethod, query, args, fetchType);
-    this.countQuery = countQuery;
+// src/logger.ts
+function defaultLogger(query, meta) {
+  console.log(`[workers-qb][${meta.duration}ms] ${JSON.stringify(query)}`);
+}
+async function asyncLoggerWrapper(query, loggerFunction, innerFunction) {
+  const start = Date.now();
+  try {
+    return await innerFunction();
+  } catch (e) {
+    throw e;
+  } finally {
+    if (loggerFunction) {
+      if (Array.isArray(query)) {
+        for (const q of query) {
+          await loggerFunction(q.toObject(), { duration: Date.now() - start });
+        }
+      } else {
+        await loggerFunction(query.toObject(), { duration: Date.now() - start });
+      }
+    }
   }
-  count() {
-    return this.executeMethod(
-      new Query(this.executeMethod, this.countQuery, this.arguments, "ONE" /* ONE */)
-    );
+}
+function syncLoggerWrapper(query, loggerFunction, innerFunction) {
+  const start = Date.now();
+  try {
+    return innerFunction();
+  } catch (e) {
+    throw e;
+  } finally {
+    if (loggerFunction) {
+      if (Array.isArray(query)) {
+        for (const q of query) {
+          loggerFunction(q.toObject(), { duration: Date.now() - start });
+        }
+      } else {
+        loggerFunction(query.toObject(), { duration: Date.now() - start });
+      }
+    }
   }
-};
-function trimQuery(query) {
-  return query.replace(/\s\s+/g, " ");
 }
 
 // src/modularBuilder.ts
@@ -163,6 +160,52 @@ var SelectBuilder = class _SelectBuilder {
       this._fetchOne
     );
   }
+  whereIn(fields, values) {
+    let whereInCondition;
+    let whereInParams;
+    const seperateWithComma = (prev, next) => prev + ", " + next;
+    if (values.length === 0) {
+      return new _SelectBuilder(
+        {
+          ...this._options
+        },
+        this._fetchAll,
+        this._fetchOne
+      );
+    }
+    if (!Array.isArray(fields)) {
+      whereInCondition = `(${fields}) IN (VALUES `;
+      whereInCondition += values.map(() => "(?)").reduce(seperateWithComma);
+      whereInCondition += ")";
+      whereInParams = values;
+    } else {
+      const fieldLength = fields.length;
+      whereInCondition = `(${fields.map((val) => val).reduce(seperateWithComma)}) IN (VALUES `;
+      const valuesString = `(${[...new Array(fieldLength).keys()].map(() => "?").reduce(seperateWithComma)})`;
+      whereInCondition += [...new Array(fieldLength).keys()].map(() => valuesString).reduce(seperateWithComma);
+      whereInCondition += ")";
+      whereInParams = values.flat();
+    }
+    let conditions = [whereInCondition];
+    let params = whereInParams;
+    if (this._options.where?.conditions) {
+      conditions = this._options.where?.conditions.concat(conditions);
+    }
+    if (this._options.where?.params) {
+      params = this._options.where?.params.concat(params);
+    }
+    return new _SelectBuilder(
+      {
+        ...this._options,
+        where: {
+          conditions,
+          params
+        }
+      },
+      this._fetchAll,
+      this._fetchOne
+    );
+  }
   join(join) {
     return this._parseArray("join", this._options.join, join);
   }
@@ -234,45 +277,50 @@ var SelectBuilder = class _SelectBuilder {
   }
 };
 
-// src/logger.ts
-function defaultLogger(query, meta) {
-  console.log(`[workers-qb][${meta.duration}ms] ${JSON.stringify(query)}`);
-}
-async function asyncLoggerWrapper(query, loggerFunction, innerFunction) {
-  const start = Date.now();
-  try {
-    return await innerFunction();
-  } catch (e) {
-    throw e;
-  } finally {
-    if (loggerFunction) {
-      if (Array.isArray(query)) {
-        for (const q of query) {
-          await loggerFunction(q.toObject(), { duration: Date.now() - start });
-        }
-      } else {
-        await loggerFunction(query.toObject(), { duration: Date.now() - start });
-      }
-    }
+// src/tools.ts
+var Raw = class {
+  isRaw = true;
+  content;
+  constructor(content) {
+    this.content = content;
   }
-}
-function syncLoggerWrapper(query, loggerFunction, innerFunction) {
-  const start = Date.now();
-  try {
-    return innerFunction();
-  } catch (e) {
-    throw e;
-  } finally {
-    if (loggerFunction) {
-      if (Array.isArray(query)) {
-        for (const q of query) {
-          loggerFunction(q.toObject(), { duration: Date.now() - start });
-        }
-      } else {
-        loggerFunction(query.toObject(), { duration: Date.now() - start });
-      }
-    }
+};
+var Query = class {
+  executeMethod;
+  query;
+  arguments;
+  fetchType;
+  constructor(executeMethod, query, args, fetchType) {
+    this.executeMethod = executeMethod;
+    this.query = trimQuery(query);
+    this.arguments = args;
+    this.fetchType = fetchType;
+  }
+  execute() {
+    return this.executeMethod(this);
+  }
+  toObject() {
+    return {
+      query: this.query,
+      args: this.arguments,
+      fetchType: this.fetchType
+    };
+  }
+};
+var QueryWithExtra = class extends Query {
+  countQuery;
+  constructor(executeMethod, query, countQuery, args, fetchType) {
+    super(executeMethod, query, args, fetchType);
+    this.countQuery = countQuery;
+  }
+  count() {
+    return this.executeMethod(
+      new Query(this.executeMethod, this.countQuery, this.arguments, "ONE" /* ONE */)
+    );
   }
+};
+function trimQuery(query) {
+  return query.replace(/\s\s+/g, " ");
 }
 
 // src/builder.ts
@@ -308,9 +356,12 @@ var QueryBuilder = class {
     );
   }
   dropTable(params) {
-    return new Query((q) => {
-      return this.execute(q);
-    }, `DROP TABLE ${params.ifExists ? "IF EXISTS" : ""} ${params.tableName}`);
+    return new Query(
+      (q) => {
+        return this.execute(q);
+      },
+      `DROP TABLE ${params.ifExists ? "IF EXISTS" : ""} ${params.tableName}`
+    );
   }
   select(tableName) {
     return new SelectBuilder(
@@ -593,6 +644,114 @@ var QueryBuilder = class {
   }
 };
 
+// src/migrations.ts
+var syncMigrationsBuilder = class {
+  _builder;
+  _migrations;
+  _tableName;
+  constructor(options, builder) {
+    this._tableName = options.tableName || "migrations";
+    this._migrations = options.migrations;
+    this._builder = builder;
+  }
+  initialize() {
+    this._builder.createTable({
+      tableName: this._tableName,
+      schema: `id         INTEGER PRIMARY KEY AUTOINCREMENT,
+               name       TEXT UNIQUE,
+               applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL`,
+      ifNotExists: true
+    }).execute();
+    return;
+  }
+  getApplied() {
+    this.initialize();
+    const result = this._builder.fetchAll({
+      tableName: this._tableName,
+      orderBy: "id"
+    }).execute();
+    return result.results || [];
+  }
+  getUnapplied() {
+    const appliedMigrations = this.getApplied().map((migration) => {
+      return migration.name;
+    });
+    const unappliedMigrations = [];
+    for (const migration of this._migrations) {
+      if (!appliedMigrations.includes(migration.name)) {
+        unappliedMigrations.push(migration);
+      }
+    }
+    return unappliedMigrations;
+  }
+  apply() {
+    const appliedMigrations = [];
+    for (const migration of this.getUnapplied()) {
+      this._builder.raw({
+        query: `
+          ${migration.sql}
+          INSERT INTO ${this._tableName} (name)
+          values ('${migration.name}');`
+      }).execute();
+      appliedMigrations.push(migration);
+    }
+    return appliedMigrations;
+  }
+};
+var asyncMigrationsBuilder = class {
+  _builder;
+  _migrations;
+  _tableName;
+  constructor(options, builder) {
+    this._tableName = options.tableName || "migrations";
+    this._migrations = options.migrations;
+    this._builder = builder;
+  }
+  async initialize() {
+    await this._builder.createTable({
+      tableName: this._tableName,
+      schema: `id         INTEGER PRIMARY KEY AUTOINCREMENT,
+               name       TEXT UNIQUE,
+               applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL`,
+      ifNotExists: true
+    }).execute();
+    return;
+  }
+  async getApplied() {
+    await this.initialize();
+    const result = await this._builder.fetchAll({
+      tableName: this._tableName,
+      orderBy: "id"
+    }).execute();
+    return result.results || [];
+  }
+  async getUnapplied() {
+    const appliedMigrations = (await this.getApplied()).map((migration) => {
+      return migration.name;
+    });
+    const unappliedMigrations = [];
+    for (const migration of this._migrations) {
+      if (!appliedMigrations.includes(migration.name)) {
+        unappliedMigrations.push(migration);
+      }
+    }
+    return unappliedMigrations;
+  }
+  async apply() {
+    const appliedMigrations = [];
+    for (const migration of await this.getUnapplied()) {
+      await this._builder.raw({
+        query: `
+          ${migration.sql}
+          INSERT INTO ${this._tableName} (name)
+          values ('${migration.name}');`
+      }).execute();
+      appliedMigrations.push(migration);
+    }
+    return appliedMigrations;
+  }
+};
+
 // src/databases/d1.ts
 var D1QB = class extends QueryBuilder {
   db;
@@ -600,6 +759,9 @@ var D1QB = class extends QueryBuilder {
     super(options);
     this.db = db;
   }
+  migrations(options) {
+    return new asyncMigrationsBuilder(options, this);
+  }
   async execute(query) {
     return await this.loggerWrapper(query, this.options.logger, async () => {
       let stmt = this.db.prepare(query.query);
@@ -662,10 +824,14 @@ var D1QB = class extends QueryBuilder {
 // src/databases/pg.ts
 var PGQB = class extends QueryBuilder {
   db;
+  _migrationsBuilder = asyncMigrationsBuilder;
   constructor(db, options) {
     super(options);
     this.db = db;
   }
+  migrations(options) {
+    return new asyncMigrationsBuilder(options, this);
+  }
   async connect() {
     await this.db.connect();
   }
@@ -711,6 +877,9 @@ var DOQB = class extends QueryBuilder {
     super(options);
     this.db = db;
   }
+  migrations(options) {
+    return new syncMigrationsBuilder(options, this);
+  }
   execute(query) {
     return this.loggerWrapper(query, this.options.logger, () => {
       let cursor;
@@ -745,7 +914,9 @@ var DOQB = class extends QueryBuilder {
   QueryWithExtra,
   Raw,
   asyncLoggerWrapper,
+  asyncMigrationsBuilder,
   defaultLogger,
   syncLoggerWrapper,
+  syncMigrationsBuilder,
   trimQuery
 });

package/dist/index.mjs

@@ -24,50 +24,45 @@ var JoinTypes = /* @__PURE__ */ ((JoinTypes2) => {
   return JoinTypes2;
 })(JoinTypes || {});
 
-// src/tools.ts
-var Raw = class {
-  isRaw = true;
-  content;
-  constructor(content) {
-    this.content = content;
-  }
-};
-var Query = class {
-  executeMethod;
-  query;
-  arguments;
-  fetchType;
-  constructor(executeMethod, query, args, fetchType) {
-    this.executeMethod = executeMethod;
-    this.query = trimQuery(query);
-    this.arguments = args;
-    this.fetchType = fetchType;
-  }
-  execute() {
-    return this.executeMethod(this);
-  }
-  toObject() {
-    return {
-      query: this.query,
-      args: this.arguments,
-      fetchType: this.fetchType
-    };
-  }
-};
-var QueryWithExtra = class extends Query {
-  countQuery;
-  constructor(executeMethod, query, countQuery, args, fetchType) {
-    super(executeMethod, query, args, fetchType);
-    this.countQuery = countQuery;
+// src/logger.ts
+function defaultLogger(query, meta) {
+  console.log(`[workers-qb][${meta.duration}ms] ${JSON.stringify(query)}`);
+}
+async function asyncLoggerWrapper(query, loggerFunction, innerFunction) {
+  const start = Date.now();
+  try {
+    return await innerFunction();
+  } catch (e) {
+    throw e;
+  } finally {
+    if (loggerFunction) {
+      if (Array.isArray(query)) {
+        for (const q of query) {
+          await loggerFunction(q.toObject(), { duration: Date.now() - start });
+        }
+      } else {
+        await loggerFunction(query.toObject(), { duration: Date.now() - start });
+      }
+    }
   }
-  count() {
-    return this.executeMethod(
-      new Query(this.executeMethod, this.countQuery, this.arguments, "ONE" /* ONE */)
-    );
+}
+function syncLoggerWrapper(query, loggerFunction, innerFunction) {
+  const start = Date.now();
+  try {
+    return innerFunction();
+  } catch (e) {
+    throw e;
+  } finally {
+    if (loggerFunction) {
+      if (Array.isArray(query)) {
+        for (const q of query) {
+          loggerFunction(q.toObject(), { duration: Date.now() - start });
+        }
+      } else {
+        loggerFunction(query.toObject(), { duration: Date.now() - start });
+      }
+    }
   }
-};
-function trimQuery(query) {
-  return query.replace(/\s\s+/g, " ");
 }
 
 // src/modularBuilder.ts
@@ -123,6 +118,52 @@ var SelectBuilder = class _SelectBuilder {
       this._fetchOne
     );
   }
+  whereIn(fields, values) {
+    let whereInCondition;
+    let whereInParams;
+    const seperateWithComma = (prev, next) => prev + ", " + next;
+    if (values.length === 0) {
+      return new _SelectBuilder(
+        {
+          ...this._options
+        },
+        this._fetchAll,
+        this._fetchOne
+      );
+    }
+    if (!Array.isArray(fields)) {
+      whereInCondition = `(${fields}) IN (VALUES `;
+      whereInCondition += values.map(() => "(?)").reduce(seperateWithComma);
+      whereInCondition += ")";
+      whereInParams = values;
+    } else {
+      const fieldLength = fields.length;
+      whereInCondition = `(${fields.map((val) => val).reduce(seperateWithComma)}) IN (VALUES `;
+      const valuesString = `(${[...new Array(fieldLength).keys()].map(() => "?").reduce(seperateWithComma)})`;
+      whereInCondition += [...new Array(fieldLength).keys()].map(() => valuesString).reduce(seperateWithComma);
+      whereInCondition += ")";
+      whereInParams = values.flat();
+    }
+    let conditions = [whereInCondition];
+    let params = whereInParams;
+    if (this._options.where?.conditions) {
+      conditions = this._options.where?.conditions.concat(conditions);
+    }
+    if (this._options.where?.params) {
+      params = this._options.where?.params.concat(params);
+    }
+    return new _SelectBuilder(
+      {
+        ...this._options,
+        where: {
+          conditions,
+          params
+        }
+      },
+      this._fetchAll,
+      this._fetchOne
+    );
+  }
   join(join) {
     return this._parseArray("join", this._options.join, join);
   }
@@ -194,45 +235,50 @@ var SelectBuilder = class _SelectBuilder {
   }
 };
 
-// src/logger.ts
-function defaultLogger(query, meta) {
-  console.log(`[workers-qb][${meta.duration}ms] ${JSON.stringify(query)}`);
-}
-async function asyncLoggerWrapper(query, loggerFunction, innerFunction) {
-  const start = Date.now();
-  try {
-    return await innerFunction();
-  } catch (e) {
-    throw e;
-  } finally {
-    if (loggerFunction) {
-      if (Array.isArray(query)) {
-        for (const q of query) {
-          await loggerFunction(q.toObject(), { duration: Date.now() - start });
-        }
-      } else {
-        await loggerFunction(query.toObject(), { duration: Date.now() - start });
-      }
-    }
+// src/tools.ts
+var Raw = class {
+  isRaw = true;
+  content;
+  constructor(content) {
+    this.content = content;
   }
-}
-function syncLoggerWrapper(query, loggerFunction, innerFunction) {
-  const start = Date.now();
-  try {
-    return innerFunction();
-  } catch (e) {
-    throw e;
-  } finally {
-    if (loggerFunction) {
-      if (Array.isArray(query)) {
-        for (const q of query) {
-          loggerFunction(q.toObject(), { duration: Date.now() - start });
-        }
-      } else {
-        loggerFunction(query.toObject(), { duration: Date.now() - start });
-      }
-    }
+};
+var Query = class {
+  executeMethod;
+  query;
+  arguments;
+  fetchType;
+  constructor(executeMethod, query, args, fetchType) {
+    this.executeMethod = executeMethod;
+    this.query = trimQuery(query);
+    this.arguments = args;
+    this.fetchType = fetchType;
+  }
+  execute() {
+    return this.executeMethod(this);
+  }
+  toObject() {
+    return {
+      query: this.query,
+      args: this.arguments,
+      fetchType: this.fetchType
+    };
+  }
+};
+var QueryWithExtra = class extends Query {
+  countQuery;
+  constructor(executeMethod, query, countQuery, args, fetchType) {
+    super(executeMethod, query, args, fetchType);
+    this.countQuery = countQuery;
+  }
+  count() {
+    return this.executeMethod(
+      new Query(this.executeMethod, this.countQuery, this.arguments, "ONE" /* ONE */)
+    );
   }
+};
+function trimQuery(query) {
+  return query.replace(/\s\s+/g, " ");
 }
 
 // src/builder.ts
@@ -268,9 +314,12 @@ var QueryBuilder = class {
     );
   }
   dropTable(params) {
-    return new Query((q) => {
-      return this.execute(q);
-    }, `DROP TABLE ${params.ifExists ? "IF EXISTS" : ""} ${params.tableName}`);
+    return new Query(
+      (q) => {
+        return this.execute(q);
+      },
+      `DROP TABLE ${params.ifExists ? "IF EXISTS" : ""} ${params.tableName}`
+    );
   }
   select(tableName) {
     return new SelectBuilder(
@@ -553,6 +602,114 @@ var QueryBuilder = class {
   }
 };
 
+// src/migrations.ts
+var syncMigrationsBuilder = class {
+  _builder;
+  _migrations;
+  _tableName;
+  constructor(options, builder) {
+    this._tableName = options.tableName || "migrations";
+    this._migrations = options.migrations;
+    this._builder = builder;
+  }
+  initialize() {
+    this._builder.createTable({
+      tableName: this._tableName,
+      schema: `id         INTEGER PRIMARY KEY AUTOINCREMENT,
+               name       TEXT UNIQUE,
+               applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL`,
+      ifNotExists: true
+    }).execute();
+    return;
+  }
+  getApplied() {
+    this.initialize();
+    const result = this._builder.fetchAll({
+      tableName: this._tableName,
+      orderBy: "id"
+    }).execute();
+    return result.results || [];
+  }
+  getUnapplied() {
+    const appliedMigrations = this.getApplied().map((migration) => {
+      return migration.name;
+    });
+    const unappliedMigrations = [];
+    for (const migration of this._migrations) {
+      if (!appliedMigrations.includes(migration.name)) {
+        unappliedMigrations.push(migration);
+      }
+    }
+    return unappliedMigrations;
+  }
+  apply() {
+    const appliedMigrations = [];
+    for (const migration of this.getUnapplied()) {
+      this._builder.raw({
+        query: `
+          ${migration.sql}
+          INSERT INTO ${this._tableName} (name)
+          values ('${migration.name}');`
+      }).execute();
+      appliedMigrations.push(migration);
+    }
+    return appliedMigrations;
+  }
+};
+var asyncMigrationsBuilder = class {
+  _builder;
+  _migrations;
+  _tableName;
+  constructor(options, builder) {
+    this._tableName = options.tableName || "migrations";
+    this._migrations = options.migrations;
+    this._builder = builder;
+  }
+  async initialize() {
+    await this._builder.createTable({
+      tableName: this._tableName,
+      schema: `id         INTEGER PRIMARY KEY AUTOINCREMENT,
+               name       TEXT UNIQUE,
+               applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL`,
+      ifNotExists: true
+    }).execute();
+    return;
+  }
+  async getApplied() {
+    await this.initialize();
+    const result = await this._builder.fetchAll({
+      tableName: this._tableName,
+      orderBy: "id"
+    }).execute();
+    return result.results || [];
+  }
+  async getUnapplied() {
+    const appliedMigrations = (await this.getApplied()).map((migration) => {
+      return migration.name;
+    });
+    const unappliedMigrations = [];
+    for (const migration of this._migrations) {
+      if (!appliedMigrations.includes(migration.name)) {
+        unappliedMigrations.push(migration);
+      }
+    }
+    return unappliedMigrations;
+  }
+  async apply() {
+    const appliedMigrations = [];
+    for (const migration of await this.getUnapplied()) {
+      await this._builder.raw({
+        query: `
+          ${migration.sql}
+          INSERT INTO ${this._tableName} (name)
+          values ('${migration.name}');`
+      }).execute();
+      appliedMigrations.push(migration);
+    }
+    return appliedMigrations;
+  }
+};
+
 // src/databases/d1.ts
 var D1QB = class extends QueryBuilder {
   db;
@@ -560,6 +717,9 @@ var D1QB = class extends QueryBuilder {
     super(options);
     this.db = db;
   }
+  migrations(options) {
+    return new asyncMigrationsBuilder(options, this);
+  }
   async execute(query) {
     return await this.loggerWrapper(query, this.options.logger, async () => {
       let stmt = this.db.prepare(query.query);
@@ -622,10 +782,14 @@ var D1QB = class extends QueryBuilder {
 // src/databases/pg.ts
 var PGQB = class extends QueryBuilder {
   db;
+  _migrationsBuilder = asyncMigrationsBuilder;
   constructor(db, options) {
     super(options);
     this.db = db;
   }
+  migrations(options) {
+    return new asyncMigrationsBuilder(options, this);
+  }
   async connect() {
     await this.db.connect();
   }
@@ -671,6 +835,9 @@ var DOQB = class extends QueryBuilder {
     super(options);
     this.db = db;
   }
+  migrations(options) {
+    return new syncMigrationsBuilder(options, this);
+  }
   execute(query) {
     return this.loggerWrapper(query, this.options.logger, () => {
       let cursor;
@@ -704,7 +871,9 @@ export {
   QueryWithExtra,
   Raw,
   asyncLoggerWrapper,
+  asyncMigrationsBuilder,
   defaultLogger,
   syncLoggerWrapper,
+  syncMigrationsBuilder,
   trimQuery
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workers-qb",
-  "version": "1.6.7",
+  "version": "1.8.0",
   "description": "Zero dependencies Query Builder for Cloudflare Workers",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -12,11 +12,9 @@
   ],
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",
-    "lint": "tsc -p tsconfig.json",
-    "test": "jest --config jest.config.cjs --no-cache --runInBand",
-    "test:cov": "jest --config jest.config.cjs --coverage --no-cache --runInBand",
-    "prettify": "prettier --check . || (prettier -w .; exit 1)",
-    "prepare": "husky install"
+    "lint": "npx @biomejs/biome check src/ tests/ || (npx @biomejs/biome check --write src/ tests/; exit 1)",
+    "test": "vitest run --root tests",
+    "prepare": "husky"
   },
   "publishConfig": {
     "access": "public"
@@ -27,6 +25,8 @@
     "workers",
     "serverless",
     "cloudflare d1",
+    "cloudflare DO",
+    "cloudflare Durable Objects",
     "d1sql",
     "sql builder",
     "query builder",
@@ -56,44 +56,13 @@
     "url": "https://github.com/G4brym/workers-qb/issues"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20240815.0",
-    "@types/jest": "^29.5.12",
-    "@typescript-eslint/eslint-plugin": "^4.31.1",
-    "@typescript-eslint/parser": "^4.31.1",
-    "changesets": "^1.0.2",
-    "eslint": "^7.32.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "husky": "^7.0.2",
-    "jest": "^29.7.0",
-    "pinst": "^2.1.6",
-    "prettier": "^2.4.0",
-    "ts-jest": "^29.1.4",
-    "tsup": "^8.1.0",
-    "typescript": "^5.4.5"
-  },
-  "prettier": {
-    "semi": false,
-    "singleQuote": true,
-    "trailingComma": "es5",
-    "arrowParens": "always",
-    "printWidth": 120
-  },
-  "eslintConfig": {
-    "parser": "@typescript-eslint/parser",
-    "extends": [
-      "plugin:@typescript-eslint/recommended",
-      "prettier"
-    ],
-    "parserOptions": {
-      "sourceType": "module"
-    },
-    "rules": {
-      "prettier/prettier": "error"
-    },
-    "plugins": [
-      "@typescript-eslint",
-      "prettier"
-    ]
+    "@biomejs/biome": "1.9.4",
+    "@cloudflare/vitest-pool-workers": "^0.5.26",
+    "@cloudflare/workers-types": "^4.20241106.0",
+    "husky": "^9.1.6",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "2.1.8",
+    "wrangler": "^3.86.0"
   }
 }