chore: wip

Author: chrisbbreuer

README.md

@@ -267,7 +267,7 @@ _Develop serverless (or server) functions with countless helpers to build scalab
 
 - 🪄 **AI** _deep AI integrations & foundational model access_
 - 🤖 **APIs** _scalability & maintainability built-in_
-- 🏎️ **Cache** _Redis, DynamoDB, and more—serverless_
+- 🏎️ **Cache** _unified caching for DynamoDB, Redis and more_
 - ⚙️ **CLIs** _create beautiful CLIs for Linux, Windows, and Mac (dependency-free binaries)_
 - 📀 **Database** _DynamoDB, SQLite, MySQL, Postgres, and more_
 - 👾 **Errors** _native type-safe error handling_

app/Models/User.ts

@@ -65,7 +65,7 @@ export default {
     },
   },
 
-  // accessors for fullname & mutoators for password
+  // accessors for fullname & mutators for password
   accessors: {
     fullname: (user: Model) => user.name,
   },

storage/framework/core/orm/src/generated/User.ts

@@ -28,9 +28,28 @@ export interface UsersTable {
   deleted_at: ColumnType<Date, string | undefined, never>
 }
 
+interface UserResponse {
+  data: Users
+  paging: {
+    total_records: number
+    page: number
+    total_pages: number
+  }
+  next_cursor: number | null
+}
+
 export type UserType = Selectable<UsersTable>
 export type NewUser = Insertable<UsersTable>
 export type UserUpdate = Updateable<UsersTable>
+export type Users = UserType[]
+
+// Define a type for the options parameter
+interface QueryOptions {
+  sort?: { column: keyof UserType, order: 'asc' | 'desc' }
+  limit?: number
+  offset?: number
+  page?: number // New
+}
 
 export class UserModel {
   private user: Partial<UserType>
@@ -73,15 +92,34 @@ export class UserModel {
   }
 
   // Method to get all users
-  static async all(limit: number = 10, offset: number = 0): Promise<UserModel[]> {
-    const users = await db.selectFrom('users')
+  static async all(options: QueryOptions = { limit: 10, offset: 0, page: 1 }): Promise<UserResponse> {
+    const totalRecordsResult = await db.selectFrom('users')
+      .select(db.fn.count('id').as('total')) // Use 'id' or another actual column name
+      .executeTakeFirst()
+
+    const totalRecords = Number(totalRecordsResult?.total) || 0
+    const totalPages = Math.ceil(totalRecords / (options.limit ?? 10))
+
+    const usersWithExtra = await db.selectFrom('users')
       .selectAll()
-      .orderBy('created_at', 'desc')
-      .limit(limit)
-      .offset(offset)
+      .orderBy('id', 'asc') // Assuming 'id' is used for cursor-based pagination
+      .limit((options.limit ?? 10) + 1) // Fetch one extra record
+      .offset((options.page! - 1) * (options.limit ?? 10))
       .execute()
 
-    return users.map(user => new UserModel(user))
+    let nextCursor = null
+    if (usersWithExtra.length > (options.limit ?? 10))
+      nextCursor = usersWithExtra.pop()!.id // Use the ID of the extra record as the next cursor
+
+    return {
+      data: usersWithExtra,
+      paging: {
+        total_records: totalRecords,
+        page: options.page!,
+        total_pages: totalPages,
+      },
+      next_cursor: nextCursor,
+    }
   }
 
   // Method to create a new user
@@ -128,27 +166,47 @@ export class UserModel {
     return new UserModel(user)
   }
 
-  async where(criteria: Partial<UserType>) {
+  async where(criteria: Partial<UserType>, options: QueryOptions = {}) {
     let query = db.selectFrom('users')
+
+    // Existing criteria checks
     if (criteria.id)
       query = query.where('id', '=', criteria.id) // Kysely is immutable, we must re-assign
+
     if (criteria.email)
       query = query.where('email', '=', criteria.email)
+
     if (criteria.name !== undefined) {
       query = query.where(
         'name',
         criteria.name === null ? 'is' : '=',
         criteria.name,
       )
     }
+
     if (criteria.password)
       query = query.where('password', '=', criteria.password)
+
     if (criteria.created_at)
       query = query.where('created_at', '=', criteria.created_at)
+
     if (criteria.updated_at)
       query = query.where('updated_at', '=', criteria.updated_at)
+
     if (criteria.deleted_at)
       query = query.where('deleted_at', '=', criteria.deleted_at)
+
+    // Apply sorting from options
+    if (options.sort)
+      query = query.orderBy(options.sort.column, options.sort.order)
+
+    // Apply pagination from options
+    if (options.limit !== undefined)
+      query = query.limit(options.limit)
+
+    if (options.offset !== undefined)
+      query = query.offset(options.offset)
+
     return await query.selectAll().execute()
   }
 
@@ -359,11 +417,15 @@ export async function findByEmail(email: string) {
     .executeTakeFirst()
 }
 
-export async function where(criteria: Partial<UserType>, sort: { column: keyof UserType, order: 'asc' | 'desc' } = { column: 'created_at', order: 'desc' }) {
+export async function where(
+  criteria: Partial<UserType>,
+  options: QueryOptions = {},
+) {
   let query = db.selectFrom('users')
 
+  // Apply criteria
   if (criteria.id)
-    query = query.where('id', '=', criteria.id) // Kysely is immutable, we must re-assign
+    query = query.where('id', '=', criteria.id)
 
   if (criteria.email)
     query = query.where('email', '=', criteria.email)
@@ -388,8 +450,16 @@ export async function where(criteria: Partial<UserType>, sort: { column: keyof U
   if (criteria.deleted_at)
     query = query.where('deleted_at', '=', criteria.deleted_at)
 
-  // Apply sorting
-  query = query.orderBy(sort.column, sort.order)
+  // Apply sorting from options
+  if (options.sort)
+    query = query.orderBy(options.sort.column, options.sort.order)
+
+  // Apply pagination from options
+  if (options.limit !== undefined)
+    query = query.limit(options.limit)
+
+  if (options.offset !== undefined)
+    query = query.offset(options.offset)
 
   return await query.selectAll().execute()
 }
@@ -407,3 +477,5 @@ export const User = {
   last,
   where,
 }
+
+export default User