@stone-js/starters 0.8.3

package/full-service-imperative/app/repositories/UserRepository.ts

@@ -0,0 +1,91 @@
+import { eq } from 'drizzle-orm'
+import { users } from '../database/schema'
+import { UserModel } from '../models/User'
+import { defineStone } from '@stone-js/core'
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+import { IUserRepository } from './contracts/IUserRepository'
+
+/**
+ * User Repository Options
+ */
+export interface UserRepositoryOptions {
+  database: LibSQLDatabase
+}
+
+/**
+ * Factory User Repository
+ */
+export function factoryUserRepository ({ database }: UserRepositoryOptions): IUserRepository {
+  return {
+    /**
+     * List users
+     *
+     * @param limit - The limit of users to list
+     * @returns The list of users
+     */
+    async list (limit: number): Promise<UserModel[]> {
+      return await database.select().from(users).limit(limit)
+    },
+
+    /**
+     * Find a user by ID
+     *
+     * @param id - The ID of the user to find
+     * @returns The user or undefined if not found
+     */
+    async findById (id: number): Promise<UserModel | undefined> {
+      const result = await database.select().from(users).where(eq(users.id, id)).get()
+      return result ?? undefined
+    },
+
+    /**
+     * Find a user by dynamic conditions
+     *
+     * @param conditions - Conditions to match the user
+     * @returns The user or undefined if not found
+     */
+    async findBy (conditions: Partial<UserModel>): Promise<UserModel | undefined> {
+      const result = await database.select().from(users).where(eq(users.email, conditions.email ?? '')).get()
+      return result ?? undefined
+    },
+
+    /**
+     * Create a user
+     *
+     * @param user - The user to create
+     * @returns The ID of the created user
+     */
+    async create (user: Omit<UserModel, 'id'>): Promise<bigint | undefined> {
+      const result = await database.insert(users).values(user)
+      return result.lastInsertRowid
+    },
+
+    /**
+     * Update a user
+     *
+     * @param id - The ID of the user to update
+     * @param user - The user data to update
+     * @returns The updated user or undefined if not found
+     */
+    async update (id: number, user: Partial<UserModel>): Promise<UserModel | undefined> {
+      const result = await database.update(users).set(user).where(eq(users.id, id)).returning().get()
+      return result ?? undefined
+    },
+
+    /**
+     * Delete a user
+     *
+     * @param id - The ID of the user to delete
+     * @returns `true` if the user was deleted, `false` if the user was not found
+     */
+    async delete (id: number): Promise<boolean> {
+      const result = await database.delete(users).where(eq(users.id, id)).run()
+      return result.rowsAffected > 0
+    }
+  }
+}
+
+/**
+ * User Repository
+ */
+export const UserRepository = defineStone(factoryUserRepository, { isFactory: true, singleton: true, alias: 'userRepository' })

package/full-service-imperative/app/repositories/contracts/ICommentRepository.ts

@@ -0,0 +1,72 @@
+import { Comment, CommentCreateModel, CommentModel } from '../../models/Comment'
+
+/**
+ * Comment Repository contract
+ */
+export interface ICommentRepository {
+  /**
+   * Retrieves a list of comments with optional filtering and sorting.
+   *
+   * @param options - Optional filters (postId, authorId, limit).
+   * @returns The list of comments.
+   */
+  list: (options?: { postId?: number, authorId?: number, limit?: number }) => Promise<Comment[]>
+
+  /**
+   * Retrieves all comments created by a specific author.
+   *
+   * @param authorId - The ID of the author.
+   * @param limit - The number of comments to retrieve.
+   * @returns The list of comments.
+   */
+  listByAuthor: (authorId: number, limit: number) => Promise<Comment[]>
+
+  /**
+   * Retrieves all comments for a specific post.
+   *
+   * @param postId - The ID of the post.
+   * @param limit - The number of comments to retrieve.
+   * @returns The list of comments.
+   */
+  listByPost: (postId: number, limit: number) => Promise<Comment[]>
+
+  /**
+   * Finds a comment by its ID.
+   *
+   * @param commentId - The ID of the comment.
+   * @returns The comment or `undefined` if not found.
+   */
+  findById: (commentId: number) => Promise<Comment | undefined>
+
+  /**
+   * Creates a new comment.
+   *
+   * @param comment - The comment data.
+   * @returns The ID of the created comment.
+   */
+  create: (comment: CommentCreateModel) => Promise<bigint | undefined>
+
+  /**
+   * Updates a comment by its ID.
+   *
+   * @param commentId - The ID of the comment to update.
+   * @param comment - The updated comment data.
+   * @returns The updated comment or `undefined` if not found.
+   */
+  update: (commentId: number, comment: Partial<CommentModel>) => Promise<Comment | undefined>
+
+  /**
+   * Deletes a comment by its ID.
+   *
+   * @param commentId - The ID of the comment to delete.
+   * @returns `true` if deleted, `false` otherwise.
+   */
+  delete: (commentId: number) => Promise<boolean>
+
+  /**
+   * Selects comment fields along with author information.
+   *
+   * @returns The selection descriptor for joined comment-author records.
+   */
+  selectWithAuthor: () => Record<string, any>
+}

package/full-service-imperative/app/repositories/contracts/IPostRepository.ts

@@ -0,0 +1,63 @@
+import { Post, PostCreateModel, PostModel } from '../../models/Post'
+
+/**
+ * Post Repository contract
+ */
+export interface IPostRepository {
+  /**
+   * Retrieves a list of posts with optional filtering and sorting.
+   *
+   * @param options - Optional filters (authorId, limit).
+   * @returns The list of posts.
+   */
+  list: (options?: { authorId?: number, limit?: number }) => Promise<Post[]>
+
+  /**
+   * Retrieves all posts created by a specific author.
+   *
+   * @param authorId - The ID of the author.
+   * @param limit - The number of posts to retrieve.
+   * @returns The list of posts.
+   */
+  listByAuthor: (authorId: number, limit: number) => Promise<Post[]>
+
+  /**
+   * Finds a post by its ID.
+   *
+   * @param postId - The ID of the post to retrieve.
+   * @returns The post or `undefined` if not found.
+   */
+  findById: (postId: number) => Promise<Post | undefined>
+
+  /**
+   * Creates a new post.
+   *
+   * @param post - The post to create.
+   * @returns The ID of the created post.
+   */
+  create: (post: PostCreateModel) => Promise<bigint | undefined>
+
+  /**
+   * Updates a post by its ID.
+   *
+   * @param postId - The ID of the post to update.
+   * @param post - The updated post data.
+   * @returns `true` if the update was successful.
+   */
+  update: (postId: number, post: Partial<PostModel>) => Promise<boolean>
+
+  /**
+   * Deletes a post by its ID.
+   *
+   * @param postId - The ID of the post to delete.
+   * @returns `true` if the post was deleted, otherwise `false`.
+   */
+  delete: (postId: number) => Promise<boolean>
+
+  /**
+   * Selects posts with author information.
+   *
+   * @returns A selection descriptor including post and author fields.
+   */
+  selectWithAuthor: () => Record<string, any>
+}

package/full-service-imperative/app/repositories/contracts/ISessionRepository.ts

@@ -0,0 +1,65 @@
+import { UserModel } from '../../models/User'
+import { Session } from '../../models/Session'
+
+/**
+ * Session Repository contract
+ */
+export interface ISessionRepository {
+  /**
+   * List sessions
+   *
+   * @param limit - The limit of sessions to list
+   * @returns The list of sessions
+   */
+  list: (limit: number) => Promise<Session[]>
+
+  /**
+   * List sessions by user
+   *
+   * @param user - The user
+   * @param limit - The limit of sessions to list
+   * @returns The list of sessions
+   */
+  listByUser: (user: UserModel, limit: number) => Promise<Session[]>
+
+  /**
+   * Find a session by ID
+   *
+   * @param id - The session ID
+   * @returns The session or undefined
+   */
+  findById: (id: number) => Promise<Session | undefined>
+
+  /**
+   * Get latest session for a user
+   *
+   * @param user - The user
+   * @returns The latest session or undefined
+   */
+  getLatest: (user: UserModel) => Promise<Session | undefined>
+
+  /**
+   * Create a session
+   *
+   * @param session - The session data
+   * @returns The created session
+   */
+  create: (session: Omit<Session, 'id'>) => Promise<Session>
+
+  /**
+   * Update a session
+   *
+   * @param id - The session ID
+   * @param session - The partial session data
+   * @returns The updated session or undefined
+   */
+  update: (id: number, session: Partial<Session>) => Promise<Session | undefined>
+
+  /**
+   * Delete a session
+   *
+   * @param id - The session ID
+   * @returns `true` if deleted, `false` otherwise
+   */
+  delete: (id: number) => Promise<boolean>
+}

package/full-service-imperative/app/repositories/contracts/IUserRepository.ts

@@ -0,0 +1,55 @@
+import { UserModel } from '../../models/User'
+
+/**
+ * User Repository contract
+ */
+export interface IUserRepository {
+  /**
+   * List users
+   *
+   * @param limit - The limit of users to list
+   * @returns The list of users
+   */
+  list: (limit: number) => Promise<UserModel[]>
+
+  /**
+   * Find a user by ID
+   *
+   * @param id - The ID of the user to find
+   * @returns The user or undefined if not found
+   */
+  findById: (id: number) => Promise<UserModel | undefined>
+
+  /**
+   * Find a user by dynamic conditions
+   *
+   * @param conditions - Conditions to match the user
+   * @returns The user or undefined if not found
+   */
+  findBy: (conditions: Partial<UserModel>) => Promise<UserModel | undefined>
+
+  /**
+   * Create a user
+   *
+   * @param user - The user to create
+   * @returns The ID of the created user
+   */
+  create: (user: Omit<UserModel, 'id'>) => Promise<bigint | undefined>
+
+  /**
+   * Update a user
+   *
+   * @param id - The ID of the user to update
+   * @param user - The user data to update
+   * @returns The updated user or undefined if not found
+   */
+  update: (id: number, user: Partial<UserModel>) => Promise<UserModel | undefined>
+
+  /**
+   * Delete a user
+   *
+   * @param id - The ID of the user to delete
+   * @returns `true` if the user was deleted, `false` if not
+   */
+  delete: (id: number) => Promise<boolean>
+}

package/full-service-imperative/app/services/CommentService.ts

@@ -0,0 +1,109 @@
+import { NotFoundError } from '@stone-js/http-core'
+import { DependencyResolver } from '@stone-js/router'
+import { Comment, CommentModel } from '../models/Comment'
+import { defineService, isNotEmpty } from '@stone-js/core'
+import { ICommentService } from './contracts/ICommentService'
+import { ICommentRepository } from '../repositories/contracts/ICommentRepository'
+
+/**
+ * Comment Service Options
+ */
+export interface CommentServiceOptions {
+  commentRepository: ICommentRepository
+}
+
+/**
+ * Factory Comment Service
+ */
+export function factoryCommentService ({ commentRepository }: CommentServiceOptions): ICommentService {
+  return {
+    /**
+     * List comments.
+     *
+     * @param limit - The limit of comments to list.
+     */
+    async list (limit: number = 10): Promise<Comment[]> {
+      return await commentRepository.list({ limit })
+    },
+
+    /**
+     * Retrieve comments for a specific post.
+     *
+     * @param postId - The post ID.
+     * @param limit - The number of comments to retrieve.
+     */
+    async listByPost (postId: number, limit: number = 10): Promise<Comment[]> {
+      return await commentRepository.list({ postId, limit })
+    },
+
+    /**
+     * Retrieve comments by a specific user.
+     *
+     * @param authorId - The author ID.
+     * @param limit - The number of comments to retrieve.
+     */
+    async listByAuthor (authorId: number, limit: number = 10): Promise<Comment[]> {
+      return await commentRepository.list({ authorId, limit })
+    },
+
+    /**
+     * Find a comment by ID.
+     *
+     * @param id - The ID of the comment.
+     * @returns The found comment.
+     */
+    async findById (id: number): Promise<Comment> {
+      const comment: Comment | undefined = await commentRepository.findById(id)
+      if (isNotEmpty<CommentModel>(comment)) return comment
+      throw new NotFoundError(`Comment with ID ${id} not found`)
+    },
+
+    /**
+     * Create a new comment.
+     *
+     * @param payload - The comment data to create.
+     */
+    async create (payload: Omit<CommentModel, 'id'>): Promise<bigint | undefined> {
+      return await commentRepository.create({ ...payload, createdAt: Date.now() })
+    },
+
+    /**
+     * Update an existing comment.
+     *
+     * @param id - The ID of the comment.
+     * @param payload - The comment data to update.
+     * @returns The updated comment.
+     */
+    async update (id: number, payload: Partial<CommentModel>): Promise<Comment> {
+      const comment: Comment | undefined = await commentRepository.update(id, payload)
+      if (isNotEmpty<CommentModel>(comment)) return comment
+      throw new NotFoundError(`Comment with ID ${id} not found`)
+    },
+
+    /**
+     * Delete a comment.
+     *
+     * @param id - The ID of the comment.
+     */
+    async delete (id: number): Promise<boolean> {
+      return await commentRepository.delete(id)
+    }
+  }
+}
+
+/**
+ * Resolve route binding.
+ *
+ * @param _key - The key of the binding.
+ * @param value - The value of the binding.
+ * @param container - The container instance.
+ */
+export async function commentResolveRouteBinding (_key: string, value: any, container?: DependencyResolver): Promise<Comment | undefined> {
+  const commentService = container?.resolve<ICommentService>('commentService')
+  return await commentService?.findById(Number(value))
+}
+
+/**
+ * Comment Service
+ */
+export const CommentService = defineService(factoryCommentService, { isFactory: true, singleton: true, alias: 'commentService' })

package/full-service-imperative/app/services/PostService.ts

@@ -0,0 +1,97 @@
+import { NotFoundError } from '@stone-js/http-core'
+import { DependencyResolver } from '@stone-js/router'
+import { IPostService } from './contracts/IPostService'
+import { defineService, isNotEmpty } from '@stone-js/core'
+import { Post, PostCreateModel, PostModel } from '../models/Post'
+import { IPostRepository } from '../repositories/contracts/IPostRepository'
+
+/**
+ * Post Service Options
+ */
+export interface PostServiceOptions {
+  postRepository: IPostRepository
+}
+
+/**
+ * Factory Post Service
+ */
+export function factoryPostService ({ postRepository }: PostServiceOptions): IPostService {
+  return {
+    /**
+     * List posts.
+     *
+     * @param limit - The limit of posts to list.
+     */
+    async list (limit: number = 10): Promise<Post[]> {
+      return await postRepository.list({ limit })
+    },
+
+    /**
+     * Retrieve posts by a specific user.
+     *
+     * @param authorId - The author ID.
+     * @param limit - The number of posts to retrieve.
+     */
+    async listByAuthor (authorId: number, limit: number = 10): Promise<Post[]> {
+      return await postRepository.listByAuthor(authorId, limit)
+    },
+
+    /**
+     * Find a post by ID.
+     *
+     * @param id - The ID of the post.
+     * @returns The found post.
+     */
+    async findById (id: number): Promise<Post> {
+      const post: Post | undefined = await postRepository.findById(id)
+      if (isNotEmpty<PostModel>(post)) return post
+      throw new NotFoundError(`Post with ID ${id} not found`)
+    },
+
+    /**
+     * Create a new post.
+     *
+     * @param payload - The post data to create.
+     */
+    async create (payload: Omit<PostCreateModel, 'id'>): Promise<bigint | undefined> {
+      return await postRepository.create({ ...payload, createdAt: Date.now(), updatedAt: Date.now() })
+    },
+
+    /**
+     * Update an existing post.
+     *
+     * @param id - The ID of the post.
+     * @param payload - The post data to update.
+     * @returns The updated post.
+     */
+    async update (id: number, payload: Partial<PostModel>): Promise<boolean> {
+      return await postRepository.update(id, payload)
+    },
+
+    /**
+     * Delete a post.
+     *
+     * @param id - The ID of the post.
+     */
+    async delete (id: number): Promise<boolean> {
+      return await postRepository.delete(id)
+    }
+  }
+}
+
+/**
+ * Resolve route binding.
+ *
+ * @param _key - The key of the binding.
+ * @param value - The value of the binding.
+ * @param container - The container instance.
+ */
+export async function postResolveRouteBinding (_key: string, value: any, container?: DependencyResolver): Promise<Post | undefined> {
+  const postService = container?.resolve<IPostService>('postService')
+  return await postService?.findById(Number(value))
+}
+
+/**
+ * Post Service
+ */
+export const PostService = defineService(factoryPostService, { isFactory: true, singleton: true, alias: 'postService' })