@getstrata/core 2.2.1 → 2.2.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @getstrata/core changelog
 
+## 2.2.3
+
+- feat(database): add scoped composite keyset pagination
+
+## 2.2.2
+
+- orm improvments
+
 ## 2.2.1
 
 F02 — complete queue durability. Queues have leased reservations, recovery and fenced acknowledgement, but still use Redis lists. Persisted retry schedules, execution deadlines, cancellation and the planned Streams migration remain unfinished. Retries currently wait inside the running worker.

package/dist/core/database/baseRepository.d.ts

@@ -1,3 +1,4 @@
+import type { KeysetCursor, KeysetOptions } from "../pagination/index.ts";
 import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
 import { type BelongsToManyRelation, type BelongsToRelation, type HasManyRelation, type HasManyThroughRelation, type MorphManyRelation, type MorphOneRelation, type MorphToRelation } from "./relationships.ts";
 import { RepositoryQuery } from "./repositoryQuery.ts";
@@ -37,6 +38,7 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
         cursorColumn?: PrimaryKey;
         direction?: "asc" | "desc";
     } & Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<CursorPaginatedResult<TEntity, TEntity[PrimaryKey]>>;
+    keysetPaginate(options: KeysetOptions<TEntity> & Omit<ExtendedQueryOptions<TEntity>, "orderBy" | "limit" | "offset">): Promise<CursorPaginatedResult<TEntity, KeysetCursor>>;
     findById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
     findByIdOrThrow(id: TEntity[PrimaryKey], errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
     findByIds(ids: readonly TEntity[PrimaryKey][]): Promise<TEntity[]>;
@@ -45,6 +47,11 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     incrementById(id: TEntity[PrimaryKey], column: keyof TEntity & string, amount?: number, extra?: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
     decrementById(id: TEntity[PrimaryKey], column: keyof TEntity & string, amount?: number, extra?: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
     create(values: MutationValues<TEntity>): Promise<TEntity>;
+    /** Set-based writes intentionally bypass per-row model observers and write casts. */
+    updateWhere(changes: UpdateValues<TEntity, PrimaryKey>, options: QueryOptions<TEntity>): Promise<number>;
+    deleteWhere(options: QueryOptions<TEntity>): Promise<number>;
+    updateWhereReturning<K extends keyof TEntity & string>(changes: UpdateValues<TEntity, PrimaryKey>, columns: readonly K[], options: QueryOptions<TEntity>): Promise<Pick<TEntity, K>[]>;
+    private executeConditionalWrite;
     updateById(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
     updateByIdOrThrow(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>, errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
     deleteById(id: TEntity[PrimaryKey]): Promise<boolean>;

package/dist/core/database/keyset.d.ts

@@ -0,0 +1,7 @@
+import type { KeysetCursor, KeysetOptions } from "../pagination/index.ts";
+import type { TableDefinition } from "./table.ts";
+import type { WhereNode } from "./whereBuilder.ts";
+declare const KEYSET_ALIAS_PREFIX = "__strata_keyset_";
+declare function validateKeyset<TEntity extends object, PK extends keyof TEntity & string>(table: TableDefinition<TEntity, PK>, options: KeysetOptions<TEntity>): KeysetCursor["order"];
+declare function keysetBoundary<TEntity extends object>(order: KeysetCursor["order"], cursor?: KeysetCursor): WhereNode<TEntity>[];
+export { KEYSET_ALIAS_PREFIX, keysetBoundary, validateKeyset };

package/dist/core/database/model.d.ts

@@ -1,10 +1,11 @@
+import type { CursorPaginatedResult, KeysetCursor, KeysetOptions } from "../pagination/index.ts";
 import BaseRepository from "./baseRepository.ts";
 import type { AnyRelationQuery, RelatedModelClass } from "./relationQuery.ts";
 import { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasManyThroughRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery } from "./relationQuery.ts";
 import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation } from "./relationships.ts";
 import type { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
-import type { ModelWhere, ModelWriteValues, QueryOptions, QueryWhere } from "./types.ts";
+import type { ModelWhere, ModelWriteValues, QueryLockOptions, QueryOptions, QueryWhere } from "./types.ts";
 type CastType = "date" | "datetime" | "json" | "bool" | "boolean" | "integer" | "int" | "hashed";
 type LoadedAttributes = Record<string, unknown>;
 type ModelCasts = Partial<Record<string, CastType>>;
@@ -55,7 +56,9 @@ declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, directi
 /** Read-only plain records; partial selection never acquires model mutation methods. */
 declare class ModelProjection<TEntity extends object, K extends keyof TEntity & string> {
     private readonly load;
-    constructor(load: (limit?: number) => Promise<Array<Pick<TEntity, K>>>);
+    private readonly page;
+    constructor(load: (limit?: number) => Promise<Array<Pick<TEntity, K>>>, page: (options: KeysetOptions<TEntity>) => Promise<CursorPaginatedResult<Pick<TEntity, K>, KeysetCursor>>);
+    keysetPaginate(options: KeysetOptions<TEntity>): Promise<CursorPaginatedResult<Pick<TEntity, K>, KeysetCursor>>;
     get(): Promise<Array<Pick<TEntity, K>>>;
     first(): Promise<Pick<TEntity, K> | null>;
 }
@@ -70,6 +73,8 @@ declare class ModelQuery<TModel extends object = AnyModel, TCounts extends strin
     /** Qualified/dynamic filters retain existing SQL semantics through an explicit escape hatch. */
     whereDynamic(input: QueryWhere<object>): this;
     select<K extends keyof ModelAttributes<TModel> & string>(...columns: readonly K[]): ModelProjection<ModelAttributes<TModel>, K>;
+    lockForUpdate(options?: QueryLockOptions): this;
+    sharedLock(options?: QueryLockOptions): this;
     orderBy(orderBy: QueryOptions<ModelAttributes<TModel>>["orderBy"]): this;
     limit(limit: number): this;
     offset(offset: number): this;
@@ -104,6 +109,10 @@ declare class ModelQuery<TModel extends object = AnyModel, TCounts extends strin
     withTrashed(): this;
     onlyTrashed(): this;
     get(): Promise<ModelQueryResult<TModel, TCounts>[]>;
+    keysetPaginate(options: KeysetOptions<ModelAttributes<TModel>>): Promise<{
+        meta: import("../pagination/index.ts").CursorPaginationMeta<KeysetCursor>;
+        data: ModelQueryResult<TModel, TCounts>[];
+    }>;
     private hydrateRows;
     first(): Promise<ModelQueryResult<TModel, TCounts> | null>;
     count(): Promise<number>;
@@ -184,6 +193,12 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     static chunk<TModel extends object>(this: {
         prototype: TModel;
     }, count: number, callback: (models: TModel[]) => Promise<boolean | void>): Promise<void>;
+    static keysetPaginate<TModel extends object>(this: {
+        prototype: TModel;
+    }, options: KeysetOptions<ModelAttributes<TModel>>): Promise<{
+        meta: import("../pagination/index.ts").CursorPaginationMeta<KeysetCursor>;
+        data: TModel[];
+    }>;
     static cursorPaginate<TModel extends object>(this: {
         prototype: TModel;
     }, options: {

package/dist/core/database/query.d.ts

@@ -68,4 +68,9 @@ declare function buildDeleteByIdQuery<TEntity extends object, PrimaryKey extends
     text: string;
     params: unknown[];
 };
-export { assertSafeProjectionExpression, buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildIncrementQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildUpsertQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, };
+/** Single-statement writes: predicates and protected scopes stay in the mutation. */
+declare function buildConditionalWriteQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, operation: "update" | "delete", changes: UpdateValues<TEntity, PrimaryKey>, options: QueryOptions<TEntity>, returning?: readonly (keyof TEntity & string)[]): {
+    text: string;
+    params: unknown[];
+};
+export { assertSafeProjectionExpression, buildAdvancedWhereClause, buildConditionalWriteQuery, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildIncrementQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildUpsertQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, };

package/dist/core/database/repositoryQuery.d.ts

@@ -1,7 +1,7 @@
-import type { PaginatedResult } from "../pagination/index.ts";
+import type { KeysetOptions, PaginatedResult } from "../pagination/index.ts";
 import type BaseRepository from "./baseRepository.ts";
 import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
-import type { QueryOptions, QueryWhere } from "./types.ts";
+import type { QueryLockOptions, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
 import { WhereBuilder } from "./whereBuilder.ts";
 type LoadedRow = Record<string, unknown>;
 declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
@@ -16,6 +16,8 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     /** Preserve completed scope predicates separately from subsequent caller OR conditions. */
     protectWhere(): this;
     orWhere(input: QueryWhere<TEntity> | ((builder: WhereBuilder<TEntity>) => void)): this;
+    lockForUpdate(options?: QueryLockOptions): this;
+    sharedLock(options?: QueryLockOptions): this;
     orderBy(orderBy: QueryOptions<TEntity>["orderBy"]): this;
     limit(limit: number): this;
     whereNull(column: keyof TEntity & string): this;
@@ -39,6 +41,10 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     withHasManyThrough<TFar extends object, LocalKey extends keyof TEntity & string, SecondKey extends keyof TFar & string, Alias extends string>(as: Alias, relation: HasManyThroughRelation<TEntity, TFar, LocalKey, string, string, SecondKey>, farRepository: BaseRepository<TFar, keyof TFar & string>, options?: Omit<QueryOptions<TFar>, "where">): this;
     withTrashed(): this;
     onlyTrashed(): this;
+    update(changes: UpdateValues<TEntity, PrimaryKey>): Promise<number>;
+    updateReturning<K extends keyof TEntity & string>(changes: UpdateValues<TEntity, PrimaryKey>, ...columns: K[]): Promise<Pick<TEntity, K>[]>;
+    delete(): Promise<number>;
+    private assertNoMutationEagerLoads;
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
     count(): Promise<number>;
@@ -60,6 +66,14 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
         meta: import("../pagination/index.ts").CursorPaginationMeta<TEntity[PrimaryKey]>;
         data: (TEntity & LoadedRow)[];
     }>;
+    keysetPaginate(options: KeysetOptions<TEntity>): Promise<{
+        meta: import("../pagination/index.ts").CursorPaginationMeta<import("../pagination/index.ts").KeysetCursor>;
+        data: (TEntity & LoadedRow)[];
+    }>;
+    projectKeyset<K extends keyof TEntity & string>(columns: readonly K[], options: KeysetOptions<TEntity>): Promise<{
+        meta: import("../pagination/index.ts").CursorPaginationMeta<import("../pagination/index.ts").KeysetCursor>;
+        data: Array<Pick<TEntity, K>>;
+    }>;
     /** Compiled query filters for batched relationship loaders. */
     getOptions(): QueryOptions<TEntity>;
     private buildOptions;

package/dist/core/database/schema/blueprint.d.ts

@@ -30,6 +30,8 @@ declare class Blueprint {
     readonly droppedIndexes: string[];
     constructor(table: string, action: BlueprintAction);
     id(name?: string): ColumnDefinition;
+    /** Generated 64-bit primary key; does not change existing id() migrations. */
+    bigId(name?: string): ColumnDefinition;
     string(name: string, length?: number): ColumnDefinition;
     text(name: string): ColumnDefinition;
     boolean(name: string): ColumnDefinition;

package/dist/core/database/schema/columnDefinition.d.ts

@@ -1,4 +1,4 @@
-type ColumnKind = "id" | "string" | "text" | "boolean" | "integer" | "bigInteger" | "timestamp" | "json" | "jsonb" | "foreignId";
+type ColumnKind = "id" | "bigId" | "string" | "text" | "boolean" | "integer" | "bigInteger" | "timestamp" | "json" | "jsonb" | "foreignId";
 interface ForeignKeyOptions {
     referencesTable: string;
     referencesColumn: string;

package/dist/core/database/types.d.ts

@@ -58,6 +58,11 @@ type QueryJoin = {
     on: QueryJoinOn[];
 };
 type QuerySelectItem = {
+    kind: "textColumn";
+    table: string;
+    column: string;
+    as: string;
+} | {
     kind: "column";
     table: string;
     column: string;
@@ -78,7 +83,16 @@ type QuerySelectItem = {
     query: string;
     as: string;
 };
+type QueryLockOptions = {
+    wait?: "wait" | "nowait" | "skipLocked";
+    /** PostgreSQL table names in this query; aliases are not inferred. */
+    of?: readonly string[];
+};
+type QueryLock = QueryLockOptions & {
+    mode: "update" | "share";
+};
 interface QueryOptions<TEntity extends object> {
+    lock?: QueryLock;
     whereNodes?: WhereNode<TEntity>[];
     where?: QueryWhere<TEntity>;
     orderBy?: QueryOrder<TEntity> | QueryOrder<TEntity>[] | QueryOrderShorthand<TEntity>;
@@ -93,4 +107,4 @@ interface QueryOptions<TEntity extends object> {
 }
 type MutationValues<TEntity> = Partial<TEntity>;
 type UpdateValues<TEntity, PrimaryKey extends keyof TEntity & string = keyof TEntity & string> = Partial<Omit<TEntity, PrimaryKey>>;
-export type { DatabaseComparable, DatabaseScalar, ModelWhere, ModelWriteValues, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, };
+export type { DatabaseComparable, DatabaseScalar, ModelWhere, ModelWriteValues, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryLock, QueryLockOptions, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, };

package/dist/core/pagination/index.d.ts

@@ -25,3 +25,24 @@ declare function buildPaginationMeta(input: {
 }): PaginationMeta;
 export type { CursorPaginatedResult, CursorPaginationMeta, PaginatedResult, PaginationMeta };
 export { buildPaginationMeta };
+/** Ordering columns must be non-null scalar fields in the underlying schema. */
+type KeysetColumn<TEntity> = {
+    [K in keyof TEntity & string]: TEntity[K] extends string | number | bigint | Date ? K : never;
+}[keyof TEntity & string];
+interface KeysetCursor {
+    version: 1;
+    order: Array<{
+        column: string;
+        direction: "asc" | "desc";
+    }>;
+    values: string[];
+}
+interface KeysetOptions<TEntity> {
+    perPage: number;
+    orderBy: readonly {
+        column: KeysetColumn<TEntity>;
+        direction: "asc" | "desc";
+    }[];
+    cursor?: KeysetCursor;
+}
+export type { KeysetColumn, KeysetCursor, KeysetOptions };

package/dist/entries/database/query.js

@@ -305,6 +305,12 @@ function buildSelectList(table, select, params = []) {
       const column = qualifyColumn(item.table, item.column);
       return item.as ? `${column} AS ${quoteIdentifier(item.as)}` : column;
     }
+    if (item.kind === "textColumn") {
+      const dialect = currentSqlDialect();
+      const column = qualifyColumn(item.table, item.column);
+      const text = dialect.driver === "sqlite" ? `CASE WHEN typeof(${column}) = 'real' THEN printf('%!.26g', ${column}) ELSE ${dialect.castToText(column)} END` : dialect.castToText(column);
+      return `${text} AS ${quoteIdentifier(item.as)}`;
+    }
     if (item.kind === "literalText") {
       return `${currentSqlDialect().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
     }
@@ -331,6 +337,31 @@ function getDefinedColumnEntries(table, values, options = {}) {
     return [[column, value]];
   });
 }
+function buildSelectLock(table, options) {
+  const lock = options.lock;
+  if (!lock)
+    return "";
+  const driver = currentSqlDialect().driver;
+  if (driver === "sqlite")
+    throw new Error("Row locks are not supported on SQLite; use an explicit write transaction.");
+  if (lock.mode !== "update" && lock.mode !== "share")
+    throw new TypeError("Invalid row lock mode.");
+  if (lock.wait !== undefined && !["wait", "nowait", "skipLocked"].includes(lock.wait))
+    throw new TypeError("Invalid row lock wait policy.");
+  if (options.groupBy || options.having)
+    throw new Error("Row locks cannot be combined with grouped/aggregate queries.");
+  let target = "";
+  if (lock.of !== undefined) {
+    if (driver !== "pgsql")
+      throw new Error("Row lock targets are supported only on PostgreSQL.");
+    const tables = [table.name, ...(options.joins ?? []).map((join) => join.table)];
+    if (!lock.of.length || lock.of.some((name) => !tables.includes(name)))
+      throw new TypeError("Row lock targets must name tables in this query.");
+    target = ` OF ${lock.of.map(quoteIdentifier).join(", ")}`;
+  }
+  const wait = lock.wait === "nowait" ? " NOWAIT" : lock.wait === "skipLocked" ? " SKIP LOCKED" : "";
+  return ` FOR ${lock.mode === "update" ? "UPDATE" : "SHARE"}${target}${wait}`;
+}
 function buildSelectQuery(table, options = {}, whereNodes = []) {
   const params = [];
   const columns = buildSelectList(table, options.select, params);
@@ -341,8 +372,9 @@ function buildSelectQuery(table, options = {}, whereNodes = []) {
   const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
   const limit = buildLimitClause(options.limit);
   const offset = buildOffsetClause(options.offset);
+  const lock = buildSelectLock(table, options);
   return {
-    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}`,
+    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}${lock}`,
     params
   };
 }
@@ -511,9 +543,52 @@ function buildDeleteByIdQuery(table, id) {
     params
   };
 }
+function buildConditionalWriteQuery(table, operation, changes, options, returning) {
+  for (const key of [
+    "joins",
+    "groupBy",
+    "having",
+    "select",
+    "orderBy",
+    "limit",
+    "offset",
+    "lock"
+  ]) {
+    if (options[key] !== undefined)
+      throw new Error(`Conditional writes do not support ${key}.`);
+  }
+  const params = [];
+  const predicate = buildAdvancedWhereClause(table.name, options.where ?? {}, options.whereNodes ?? []);
+  if (!predicate.clause)
+    throw new Error("Conditional writes require an explicit predicate.");
+  if (returning !== undefined && currentSqlDialect().driver === "mysql")
+    throw new Error("Mutation RETURNING is not supported on MySQL.");
+  const columns = returning ?? [table.primaryKey];
+  if (!columns.length || columns.some((column) => !table.columns.includes(column)))
+    throw new Error("RETURNING columns must be nonempty declared table columns.");
+  const deletedAt = resolveSoftDeleteColumn(table);
+  const values = operation === "delete" && deletedAt ? { [deletedAt]: new Date } : changes;
+  let prefix;
+  if (operation === "update" || deletedAt) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (!entries.length)
+      throw new Error("Conditional updates require at least one value.");
+    if (entries.some(([column]) => column === table.primaryKey || !table.columns.includes(column)))
+      throw new Error("Conditional updates require declared non-primary-key columns.");
+    const assignments = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`);
+    prefix = `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")}`;
+  } else
+    prefix = `DELETE FROM ${quoteIdentifier(table.name)}`;
+  const { clause } = buildQueryWhereClause(table, options, options.whereNodes ?? [], params);
+  return {
+    text: prefix + clause + returningSuffix(columns.map(quoteIdentifier).join(", ")),
+    params
+  };
+}
 export {
   assertSafeProjectionExpression,
   buildAdvancedWhereClause,
+  buildConditionalWriteQuery,
   buildCountQuery,
   buildDeleteByIdQuery,
   buildGroupedCountQuery,

package/dist/entries/database/repositoryQuery.js

@@ -329,6 +329,12 @@ function buildSelectList(table, select, params = []) {
       const column = qualifyColumn(item.table, item.column);
       return item.as ? `${column} AS ${quoteIdentifier(item.as)}` : column;
     }
+    if (item.kind === "textColumn") {
+      const dialect = currentSqlDialect();
+      const column = qualifyColumn(item.table, item.column);
+      const text = dialect.driver === "sqlite" ? `CASE WHEN typeof(${column}) = 'real' THEN printf('%!.26g', ${column}) ELSE ${dialect.castToText(column)} END` : dialect.castToText(column);
+      return `${text} AS ${quoteIdentifier(item.as)}`;
+    }
     if (item.kind === "literalText") {
       return `${currentSqlDialect().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
     }
@@ -355,6 +361,31 @@ function getDefinedColumnEntries(table, values, options = {}) {
     return [[column, value]];
   });
 }
+function buildSelectLock(table, options) {
+  const lock = options.lock;
+  if (!lock)
+    return "";
+  const driver = currentSqlDialect().driver;
+  if (driver === "sqlite")
+    throw new Error("Row locks are not supported on SQLite; use an explicit write transaction.");
+  if (lock.mode !== "update" && lock.mode !== "share")
+    throw new TypeError("Invalid row lock mode.");
+  if (lock.wait !== undefined && !["wait", "nowait", "skipLocked"].includes(lock.wait))
+    throw new TypeError("Invalid row lock wait policy.");
+  if (options.groupBy || options.having)
+    throw new Error("Row locks cannot be combined with grouped/aggregate queries.");
+  let target = "";
+  if (lock.of !== undefined) {
+    if (driver !== "pgsql")
+      throw new Error("Row lock targets are supported only on PostgreSQL.");
+    const tables = [table.name, ...(options.joins ?? []).map((join) => join.table)];
+    if (!lock.of.length || lock.of.some((name) => !tables.includes(name)))
+      throw new TypeError("Row lock targets must name tables in this query.");
+    target = ` OF ${lock.of.map(quoteIdentifier).join(", ")}`;
+  }
+  const wait = lock.wait === "nowait" ? " NOWAIT" : lock.wait === "skipLocked" ? " SKIP LOCKED" : "";
+  return ` FOR ${lock.mode === "update" ? "UPDATE" : "SHARE"}${target}${wait}`;
+}
 function buildSelectQuery(table, options = {}, whereNodes = []) {
   const params = [];
   const columns = buildSelectList(table, options.select, params);
@@ -365,8 +396,9 @@ function buildSelectQuery(table, options = {}, whereNodes = []) {
   const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
   const limit = buildLimitClause(options.limit);
   const offset = buildOffsetClause(options.offset);
+  const lock = buildSelectLock(table, options);
   return {
-    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}`,
+    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}${lock}`,
     params
   };
 }
@@ -535,6 +567,48 @@ function buildDeleteByIdQuery(table, id) {
     params
   };
 }
+function buildConditionalWriteQuery(table, operation, changes, options, returning) {
+  for (const key of [
+    "joins",
+    "groupBy",
+    "having",
+    "select",
+    "orderBy",
+    "limit",
+    "offset",
+    "lock"
+  ]) {
+    if (options[key] !== undefined)
+      throw new Error(`Conditional writes do not support ${key}.`);
+  }
+  const params = [];
+  const predicate = buildAdvancedWhereClause(table.name, options.where ?? {}, options.whereNodes ?? []);
+  if (!predicate.clause)
+    throw new Error("Conditional writes require an explicit predicate.");
+  if (returning !== undefined && currentSqlDialect().driver === "mysql")
+    throw new Error("Mutation RETURNING is not supported on MySQL.");
+  const columns = returning ?? [table.primaryKey];
+  if (!columns.length || columns.some((column) => !table.columns.includes(column)))
+    throw new Error("RETURNING columns must be nonempty declared table columns.");
+  const deletedAt = resolveSoftDeleteColumn(table);
+  const values = operation === "delete" && deletedAt ? { [deletedAt]: new Date } : changes;
+  let prefix;
+  if (operation === "update" || deletedAt) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (!entries.length)
+      throw new Error("Conditional updates require at least one value.");
+    if (entries.some(([column]) => column === table.primaryKey || !table.columns.includes(column)))
+      throw new Error("Conditional updates require declared non-primary-key columns.");
+    const assignments = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`);
+    prefix = `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")}`;
+  } else
+    prefix = `DELETE FROM ${quoteIdentifier(table.name)}`;
+  const { clause } = buildQueryWhereClause(table, options, options.whereNodes ?? [], params);
+  return {
+    text: prefix + clause + returningSuffix(columns.map(quoteIdentifier).join(", ")),
+    params
+  };
+}
 
 // ../../src/core/database/relationships.ts
 function hasMany(definition) {
@@ -856,6 +930,20 @@ class RepositoryQuery {
     this.whereNodes.push({ kind: "or", where: input });
     return this;
   }
+  lockForUpdate(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "update" }
+    };
+    return this;
+  }
+  sharedLock(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "share" }
+    };
+    return this;
+  }
   orderBy(orderBy) {
     this.queryOptions = { ...this.queryOptions, orderBy };
     return this;
@@ -995,6 +1083,22 @@ class RepositoryQuery {
     this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
     return this;
   }
+  async update(changes) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhere(changes, this.buildOptions());
+  }
+  async updateReturning(changes, ...columns) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhereReturning(changes, columns, this.buildOptions());
+  }
+  async delete() {
+    this.assertNoMutationEagerLoads();
+    return this.repository.deleteWhere(this.buildOptions());
+  }
+  assertNoMutationEagerLoads() {
+    if (this.eagerLoads.length)
+      throw new Error("Conditional writes do not support eager loading.");
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -1059,6 +1163,20 @@ class RepositoryQuery {
     const page = await this.repository.cursorPaginate({ ...this.buildOptions(), ...options });
     return { ...page, data: await this.attach(page.data) };
   }
+  async keysetPaginate(options) {
+    const page = await this.repository.keysetPaginate({ ...this.buildOptions(), ...options });
+    return { ...page, data: await this.attach(page.data) };
+  }
+  async projectKeyset(columns, options) {
+    if (!columns.length || columns.some((column) => !this.repository.getTable().columns.includes(column)))
+      throw new TypeError("Keyset projections require declared columns.");
+    const page = await this.repository.keysetPaginate({
+      ...this.buildOptions(),
+      ...options,
+      select: uniqueColumnSelect(this.repository.getTable().name, columns)
+    });
+    return { ...page, data: page.data };
+  }
   getOptions() {
     return this.buildOptions();
   }

package/dist/entries/database/schema.js

@@ -340,6 +340,13 @@ class Blueprint {
     this.columns.push(column);
     return column;
   }
+  bigId(name = "id") {
+    const column = new ColumnDefinition(name, "bigId");
+    column.primary();
+    column.autoIncrement = true;
+    this.columns.push(column);
+    return column;
+  }
   string(name, length) {
     if (length !== undefined && (!Number.isSafeInteger(length) || length <= 0)) {
       throw new Error("String length must be a positive safe integer.");
@@ -486,6 +493,8 @@ init_dialect();
 // ../../src/core/database/schema/grammars/grammar.ts
 function compileColumnType(driver, column) {
   switch (column.kind) {
+    case "bigId":
+      return driver === "pgsql" ? "BIGSERIAL" : compileIdType(driver);
     case "id":
       return compileIdType(driver);
     case "string":

package/dist/entries/database/sqliteConnection.js

@@ -69,7 +69,7 @@ function createSqliteConnection(filename) {
   const transactions = new WeakSet;
   function execute(query, params) {
     const statement = db.query(query);
-    const args = [...params];
+    const args = params.map((value) => value instanceof Date ? value.toISOString() : value);
     if (isRowReturning(query))
       return statement.all(...args);
     statement.run(...args);

package/dist/framework/public-api.d.ts

@@ -126,7 +126,7 @@ export type { MetricLabels } from "../core/metrics/prometheus.ts";
 export { PrometheusRegistry, prometheusRegistry } from "../core/metrics/prometheus.ts";
 export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, } from "../core/notifications/index.ts";
 export { createNotificationDispatcher, Notification, NotificationDispatcher, } from "../core/notifications/index.ts";
-export type { CursorPaginatedResult, PaginatedResult, PaginationMeta, } from "../core/pagination/index.ts";
+export type { CursorPaginatedResult, KeysetColumn, KeysetCursor, KeysetOptions, PaginatedResult, PaginationMeta, } from "../core/pagination/index.ts";
 export type { Queue, QueuePriority } from "../core/queue/index.ts";
 export { AsyncQueue, createQueue, Job, SyncQueue } from "../core/queue/index.ts";
 export { JobRegistry } from "../core/queue/jobRegistry.ts";

package/dist/index.js

@@ -4131,6 +4131,45 @@ function buildPaginationMeta(input) {
 init_connectionContext();
 init_dialect();
 
+// ../../src/core/database/keyset.ts
+var KEYSET_ALIAS_PREFIX = "__strata_keyset_";
+function validateKeyset(table, options) {
+  if (!Number.isInteger(options.perPage) || options.perPage < 1 || options.perPage > 1000)
+    throw new RangeError("Keyset page size must be between 1 and 1000.");
+  if (!Array.isArray(options.orderBy) || options.orderBy.length < 1 || options.orderBy.length > 8)
+    throw new TypeError("Keyset ordering requires between 1 and 8 columns.");
+  if (table.columns.some((column) => column.toLowerCase().startsWith(KEYSET_ALIAS_PREFIX)))
+    throw new TypeError("Table columns conflict with reserved keyset aliases.");
+  const seen = new Set;
+  const order = Array.from(options.orderBy).map(({ column, direction }) => {
+    if (!table.columns.includes(column) || seen.has(column) || !["asc", "desc"].includes(direction))
+      throw new TypeError("Invalid or duplicate keyset ordering column/direction.");
+    seen.add(column);
+    return { column, direction };
+  });
+  if (order.at(-1)?.column !== table.primaryKey)
+    throw new TypeError("Keyset ordering must end with the table primary key.");
+  if (options.cursor !== undefined) {
+    const cursor = options.cursor;
+    if (cursor?.version !== 1 || !Array.isArray(cursor.order) || cursor.order.length !== order.length || !Array.isArray(cursor.values) || cursor.values.length !== order.length || Array.from(cursor.order).some((item, i) => !item || item.column !== order[i]?.column || item.direction !== order[i]?.direction) || Array.from(cursor.values).some((value) => typeof value !== "string" || value.length > 4096))
+      throw new TypeError("Invalid keyset cursor or ordering mismatch.");
+  }
+  return order;
+}
+function keysetBoundary(order, cursor) {
+  if (!cursor)
+    return [];
+  const branches = order.map((item, i) => {
+    const where = {};
+    order.slice(0, i).forEach((prefix, j) => {
+      where[prefix.column] = cursor.values[j];
+    });
+    where[item.column] = { [item.direction === "asc" ? "gt" : "lt"]: cursor.values[i] };
+    return { kind: i === 0 ? "and" : "or", where };
+  });
+  return [{ kind: "and", group: branches }];
+}
+
 // ../../src/core/database/query.ts
 init_dialect();
 function quoteIdentifier(identifier) {
@@ -4437,6 +4476,12 @@ function buildSelectList(table, select, params = []) {
       const column = qualifyColumn(item.table, item.column);
       return item.as ? `${column} AS ${quoteIdentifier(item.as)}` : column;
     }
+    if (item.kind === "textColumn") {
+      const dialect = currentSqlDialect();
+      const column = qualifyColumn(item.table, item.column);
+      const text = dialect.driver === "sqlite" ? `CASE WHEN typeof(${column}) = 'real' THEN printf('%!.26g', ${column}) ELSE ${dialect.castToText(column)} END` : dialect.castToText(column);
+      return `${text} AS ${quoteIdentifier(item.as)}`;
+    }
     if (item.kind === "literalText") {
       return `${currentSqlDialect().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
     }
@@ -4463,6 +4508,31 @@ function getDefinedColumnEntries(table, values, options = {}) {
     return [[column, value]];
   });
 }
+function buildSelectLock(table, options) {
+  const lock = options.lock;
+  if (!lock)
+    return "";
+  const driver = currentSqlDialect().driver;
+  if (driver === "sqlite")
+    throw new Error("Row locks are not supported on SQLite; use an explicit write transaction.");
+  if (lock.mode !== "update" && lock.mode !== "share")
+    throw new TypeError("Invalid row lock mode.");
+  if (lock.wait !== undefined && !["wait", "nowait", "skipLocked"].includes(lock.wait))
+    throw new TypeError("Invalid row lock wait policy.");
+  if (options.groupBy || options.having)
+    throw new Error("Row locks cannot be combined with grouped/aggregate queries.");
+  let target = "";
+  if (lock.of !== undefined) {
+    if (driver !== "pgsql")
+      throw new Error("Row lock targets are supported only on PostgreSQL.");
+    const tables = [table.name, ...(options.joins ?? []).map((join) => join.table)];
+    if (!lock.of.length || lock.of.some((name) => !tables.includes(name)))
+      throw new TypeError("Row lock targets must name tables in this query.");
+    target = ` OF ${lock.of.map(quoteIdentifier).join(", ")}`;
+  }
+  const wait = lock.wait === "nowait" ? " NOWAIT" : lock.wait === "skipLocked" ? " SKIP LOCKED" : "";
+  return ` FOR ${lock.mode === "update" ? "UPDATE" : "SHARE"}${target}${wait}`;
+}
 function buildSelectQuery(table, options = {}, whereNodes = []) {
   const params = [];
   const columns = buildSelectList(table, options.select, params);
@@ -4473,8 +4543,9 @@ function buildSelectQuery(table, options = {}, whereNodes = []) {
   const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
   const limit = buildLimitClause(options.limit);
   const offset = buildOffsetClause(options.offset);
+  const lock = buildSelectLock(table, options);
   return {
-    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}`,
+    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}${lock}`,
     params
   };
 }
@@ -4643,6 +4714,48 @@ function buildDeleteByIdQuery(table, id) {
     params
   };
 }
+function buildConditionalWriteQuery(table, operation, changes, options, returning) {
+  for (const key of [
+    "joins",
+    "groupBy",
+    "having",
+    "select",
+    "orderBy",
+    "limit",
+    "offset",
+    "lock"
+  ]) {
+    if (options[key] !== undefined)
+      throw new Error(`Conditional writes do not support ${key}.`);
+  }
+  const params = [];
+  const predicate = buildAdvancedWhereClause(table.name, options.where ?? {}, options.whereNodes ?? []);
+  if (!predicate.clause)
+    throw new Error("Conditional writes require an explicit predicate.");
+  if (returning !== undefined && currentSqlDialect().driver === "mysql")
+    throw new Error("Mutation RETURNING is not supported on MySQL.");
+  const columns = returning ?? [table.primaryKey];
+  if (!columns.length || columns.some((column) => !table.columns.includes(column)))
+    throw new Error("RETURNING columns must be nonempty declared table columns.");
+  const deletedAt = resolveSoftDeleteColumn(table);
+  const values = operation === "delete" && deletedAt ? { [deletedAt]: new Date } : changes;
+  let prefix;
+  if (operation === "update" || deletedAt) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (!entries.length)
+      throw new Error("Conditional updates require at least one value.");
+    if (entries.some(([column]) => column === table.primaryKey || !table.columns.includes(column)))
+      throw new Error("Conditional updates require declared non-primary-key columns.");
+    const assignments = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`);
+    prefix = `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")}`;
+  } else
+    prefix = `DELETE FROM ${quoteIdentifier(table.name)}`;
+  const { clause } = buildQueryWhereClause(table, options, options.whereNodes ?? [], params);
+  return {
+    text: prefix + clause + returningSuffix(columns.map(quoteIdentifier).join(", ")),
+    params
+  };
+}
 
 // ../../src/core/database/relationships.ts
 function hasMany(definition) {
@@ -4991,6 +5104,20 @@ class RepositoryQuery {
     this.whereNodes.push({ kind: "or", where: input });
     return this;
   }
+  lockForUpdate(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "update" }
+    };
+    return this;
+  }
+  sharedLock(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "share" }
+    };
+    return this;
+  }
   orderBy(orderBy) {
     this.queryOptions = { ...this.queryOptions, orderBy };
     return this;
@@ -5130,6 +5257,22 @@ class RepositoryQuery {
     this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
     return this;
   }
+  async update(changes) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhere(changes, this.buildOptions());
+  }
+  async updateReturning(changes, ...columns) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhereReturning(changes, columns, this.buildOptions());
+  }
+  async delete() {
+    this.assertNoMutationEagerLoads();
+    return this.repository.deleteWhere(this.buildOptions());
+  }
+  assertNoMutationEagerLoads() {
+    if (this.eagerLoads.length)
+      throw new Error("Conditional writes do not support eager loading.");
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -5194,6 +5337,20 @@ class RepositoryQuery {
     const page = await this.repository.cursorPaginate({ ...this.buildOptions(), ...options });
     return { ...page, data: await this.attach(page.data) };
   }
+  async keysetPaginate(options) {
+    const page = await this.repository.keysetPaginate({ ...this.buildOptions(), ...options });
+    return { ...page, data: await this.attach(page.data) };
+  }
+  async projectKeyset(columns, options) {
+    if (!columns.length || columns.some((column) => !this.repository.getTable().columns.includes(column)))
+      throw new TypeError("Keyset projections require declared columns.");
+    const page = await this.repository.keysetPaginate({
+      ...this.buildOptions(),
+      ...options,
+      select: uniqueColumnSelect(this.repository.getTable().name, columns)
+    });
+    return { ...page, data: page.data };
+  }
   getOptions() {
     return this.buildOptions();
   }
@@ -5335,11 +5492,16 @@ class BaseRepository {
     return runInTransaction(operation);
   }
   async count(options = {}) {
+    if (options.lock)
+      throw new Error("Row locks require a row selection, not count().");
     const { whereNodes, where, ...rest } = options;
     return await this.countWhere(where ?? {}, rest, whereNodes ?? []);
   }
   async findAll(options = {}) {
     return await withDatabaseErrorHandling(async () => {
+      if (options.lock && (!hasActiveTransaction() || this.connection !== repositoryConnection && this.connection !== getActiveDatabaseConnection(repositoryConnection))) {
+        throw new Error("Row locks require the framework active transaction connection.");
+      }
       const { whereNodes, ...queryOptions } = options;
       const { text, params } = buildSelectQuery(this.table, queryOptions, whereNodes ?? []);
       return await this.connection.unsafe(text, params);
@@ -5454,6 +5616,65 @@ class BaseRepository {
       }
     };
   }
+  async keysetPaginate(options) {
+    const order = validateKeyset(this.table, options);
+    if (options.joins?.length || options.groupBy || options.having || "offset" in options || "limit" in options)
+      throw new TypeError("Keyset pagination does not accept joined/grouped/offset/limited queries.");
+    if (options.select?.some((item) => item.as?.toLowerCase().startsWith(KEYSET_ALIAS_PREFIX)))
+      throw new TypeError("Projection conflicts with reserved keyset aliases.");
+    const filters = [...options.whereNodes ?? []];
+    if (options.where)
+      filters.push({ kind: "and", where: options.where });
+    const rows = await this.findAll({
+      ...options,
+      where: {},
+      whereNodes: [
+        { kind: "and", group: filters },
+        ...keysetBoundary(order, options.cursor)
+      ],
+      orderBy: order,
+      limit: options.perPage + 1,
+      select: [
+        ...options.select?.length ? options.select : this.table.columns.map((column) => ({
+          kind: "column",
+          table: this.table.name,
+          column
+        })),
+        ...order.map((item, i) => ({
+          kind: "textColumn",
+          table: this.table.name,
+          column: item.column,
+          as: `${KEYSET_ALIAS_PREFIX}${i}`
+        }))
+      ]
+    });
+    const entries = rows.map((row) => {
+      const record = { ...row };
+      const values = order.map((_, i) => {
+        const key = `${KEYSET_ALIAS_PREFIX}${i}`;
+        const value = record[key];
+        delete record[key];
+        if (typeof value !== "string" || value.length > 4096)
+          throw new TypeError("Keyset columns must contain non-null bounded scalar values.");
+        return value;
+      });
+      return { record, values };
+    });
+    const hasMore = entries.length > options.perPage;
+    const visible = entries.slice(0, options.perPage);
+    const last = visible.at(-1);
+    const nextCursor = hasMore && last ? { version: 1, order, values: last.values } : null;
+    const data = visible.map(({ record }) => record);
+    return {
+      data,
+      meta: {
+        per_page: options.perPage,
+        has_more: hasMore,
+        next_cursor: nextCursor,
+        prev_cursor: options.cursor ?? null
+      }
+    };
+  }
   async findById(id) {
     return await this.firstOrNull({
       [this.table.primaryKey]: id
@@ -5509,6 +5730,28 @@ class BaseRepository {
       return entity;
     }));
   }
+  async updateWhere(changes, options) {
+    return this.executeConditionalWrite("update", changes, options);
+  }
+  async deleteWhere(options) {
+    return this.executeConditionalWrite("delete", {}, options);
+  }
+  async updateWhereReturning(changes, columns, options) {
+    const { text, params } = buildConditionalWriteQuery(this.table, "update", changes, options, columns);
+    return withDatabaseErrorHandling(() => this.connection.unsafe(text, params));
+  }
+  async executeConditionalWrite(operation, changes, options) {
+    const { text, params } = buildConditionalWriteQuery(this.table, operation, changes, options);
+    return withDatabaseErrorHandling(async () => {
+      const rows = await this.connection.unsafe(text, params);
+      if (currentSqlDialect().driver !== "mysql")
+        return rows.length;
+      const affected = rows[0]?.affectedRows;
+      if (!Number.isSafeInteger(affected) || affected === undefined || affected < 0)
+        throw new Error("MySQL conditional writes require affectedRows metadata from the framework adapter.");
+      return affected;
+    });
+  }
   async updateById(id, changes) {
     this.assertTransactionalEvent("updated");
     return await this.runModelMutation("updated", () => withDatabaseErrorHandling(async () => {
@@ -7119,8 +7362,13 @@ function applyTimestampsOnUpdate(columns, values, enabled) {
 
 class ModelProjection {
   load;
-  constructor(load) {
+  page;
+  constructor(load, page) {
     this.load = load;
+    this.page = page;
+  }
+  keysetPaginate(options) {
+    return this.page(options);
   }
   get() {
     return this.load();
@@ -7170,8 +7418,22 @@ class ModelQuery {
     return new ModelProjection(async (limit) => {
       const rows = await this.query.project(columns, limit);
       return rows.map((row) => applyCasts(row, modelStatics(this.modelClass).$casts, "hydrate"));
+    }, async (options) => {
+      const page = await this.query.projectKeyset(columns, options);
+      return {
+        ...page,
+        data: page.data.map((row) => applyCasts(row, modelStatics(this.modelClass).$casts, "hydrate"))
+      };
     });
   }
+  lockForUpdate(options = {}) {
+    this.query.lockForUpdate(options);
+    return this;
+  }
+  sharedLock(options = {}) {
+    this.query.sharedLock(options);
+    return this;
+  }
   orderBy(orderBy) {
     this.query.orderBy(orderBy);
     return this;
@@ -7279,6 +7541,10 @@ class ModelQuery {
   async get() {
     return await this.hydrateRows(await this.query.get());
   }
+  async keysetPaginate(options) {
+    const page = await this.query.keysetPaginate(options);
+    return { ...page, data: await this.hydrateRows(page.data) };
+  }
   async hydrateRows(rows) {
     const statics = modelStatics(this.modelClass);
     const models = [];
@@ -7562,6 +7828,9 @@ class Model {
       return await callback(rows.map((row) => statics.newFromRecord(row, true)));
     });
   }
+  static keysetPaginate(options) {
+    return Model.query.call(this).keysetPaginate(options);
+  }
   static async cursorPaginate(options) {
     const statics = modelStatics(this);
     ensureBooted(this);
@@ -8200,6 +8469,13 @@ class Blueprint {
     this.columns.push(column);
     return column;
   }
+  bigId(name = "id") {
+    const column = new ColumnDefinition(name, "bigId");
+    column.primary();
+    column.autoIncrement = true;
+    this.columns.push(column);
+    return column;
+  }
   string(name, length) {
     if (length !== undefined && (!Number.isSafeInteger(length) || length <= 0)) {
       throw new Error("String length must be a positive safe integer.");
@@ -8346,6 +8622,8 @@ init_dialect();
 // ../../src/core/database/schema/grammars/grammar.ts
 function compileColumnType(driver, column) {
   switch (column.kind) {
+    case "bigId":
+      return driver === "pgsql" ? "BIGSERIAL" : compileIdType(driver);
     case "id":
       return compileIdType(driver);
     case "string":
@@ -8781,7 +9059,7 @@ function createSqliteConnection(filename) {
   const transactions = new WeakSet;
   function execute(query, params) {
     const statement = db.query(query);
-    const args = [...params];
+    const args = params.map((value) => value instanceof Date ? value.toISOString() : value);
     if (isRowReturning(query))
       return statement.all(...args);
     statement.run(...args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",