@stone-js/starters 0.8.3

package/full-service-declarative/app/models/User.ts

@@ -0,0 +1,77 @@
+import jwt from 'jsonwebtoken'
+import { Session } from './Session'
+
+/**
+ * User Interface
+*/
+export interface UserModel {
+  id: number
+  name: string
+  email: string
+  avatar?: string | null
+  password?: string | null
+  createdAt: number
+  updatedAt: number
+}
+
+/**
+ * User Interface
+*/
+export interface User extends Omit<UserModel, 'password'> {}
+
+/**
+ * User Response Interface
+ * Represents a user response resource.
+*/
+export interface UserResponse extends User {}
+
+/**
+ * User Request Interface
+ * Represents a user request resource.
+*/
+export interface UserRequest {
+  name: string
+  email: string
+}
+
+/**
+ * User Login Interface
+*/
+export interface UserLogin {
+  email: string
+  password: string
+}
+
+/**
+ * User Register Interface
+*/
+export interface UserRegister {
+  name: string
+  email: string
+  password: string
+}
+
+/**
+ * User Change Password Interface
+*/
+export interface UserChangePassword {
+  password: string
+  newPassword: string
+}
+
+/**
+ * User Token Interface
+*/
+export interface UserToken {
+  expiresIn: number
+  tokenType: string
+  accessToken: string
+}
+
+/**
+ * User Token Payload Interface
+*/
+export interface UserTokenPayload extends jwt.JwtPayload {
+  user: User
+  session: Session
+}

package/full-service-declarative/app/providers/DrizzleServiceProvider.ts

@@ -0,0 +1,59 @@
+import {
+  Hook,
+  Provider,
+  IContainer,
+  IServiceProvider,
+  AdapterHookListenerContext
+} from '@stone-js/core'
+import { Config } from '@libsql/client'
+import { drizzle } from 'drizzle-orm/libsql'
+import { DatabaseClient } from '../database/DatabaseClient'
+
+/**
+ * Drizzle Service Provider
+ *
+ * In this example, we are using both ServiceProvider to bind the drizzle instance to the container
+ * And AdapterHook to start and stop the drizzle client
+ */
+@Provider()
+export class DrizzleServiceProvider implements IServiceProvider {
+  /**
+   * Create a new instance of DrizzleServiceProvider
+   *
+   * @param options
+   */
+  constructor (private readonly container: IContainer) {}
+
+  /**
+   * On start hook that will be called
+   * once when the application starts
+   *
+   * @param context - The adapter hook listener context
+   */
+  @Hook('onStart')
+  onStart ({ blueprint }: AdapterHookListenerContext): void {
+    DatabaseClient.create(
+      blueprint.get<Config>('database', { url: 'file:local.db' })
+    )
+  }
+
+  /**
+   * Register services to the container
+   */
+  register (): void {
+    this.container
+      .instanceIf('drizzle', drizzle(DatabaseClient.client))
+      .alias('drizzle', ['db', 'database'])
+  }
+
+  /**
+   * On stop hook that will be called
+   * once when the application stops
+   *
+   * @param context - The adapter hook listener context
+   */
+  @Hook('onStop')
+  onStop (): void {
+    DatabaseClient.close()
+  }
+}

package/full-service-declarative/app/repositories/CommentRepository.ts

@@ -0,0 +1,155 @@
+import { desc, eq } from 'drizzle-orm'
+import { isNotEmpty, Stone } from '@stone-js/core'
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+import { comments, users } from '../database/schema'
+import { Comment, CommentCreateModel, CommentModel } from '../models/Comment'
+
+/**
+ * Comment Repository Options
+ */
+export interface CommentRepositoryOptions {
+  database: LibSQLDatabase
+}
+
+/**
+ * Comment Repository
+ *
+ * Manages comment-related database operations.
+ */
+@Stone({ alias: 'commentRepository' })
+export class CommentRepository {
+  private readonly database: LibSQLDatabase
+
+  /**
+   * Create a new instance of CommentRepository.
+   *
+   * @param options - The options to create the repository.
+   */
+  constructor ({ database }: CommentRepositoryOptions) {
+    this.database = database
+  }
+
+  /**
+   * Retrieves a list of comments with optional filtering and sorting.
+   *
+   * @param options - Optional filters (postId, authorId, limit, orderBy).
+   * @returns The list of comments.
+   */
+  async list (options?: { postId?: number, authorId?: number, limit?: number }): Promise<Comment[]> {
+    const query = this
+      .database
+      .select(this.selectWithAuthor())
+      .from(comments)
+      .innerJoin(users, eq(comments.authorId, users.id))
+
+    if (options?.postId !== undefined) {
+      await query.where(eq(comments.postId, options.postId))
+    }
+
+    if (options?.authorId !== undefined) {
+      await query.where(eq(comments.authorId, options.authorId))
+    }
+
+    await query.orderBy(desc(comments.createdAt))
+
+    if (options?.limit !== undefined) {
+      await query.limit(options.limit)
+    }
+
+    return await query.all() as Comment[]
+  }
+
+  /**
+   * Retrieves all comments created by a specific user.
+   *
+   * @param authorId - The ID of the user whose comments are being retrieved.
+   * @param limit - The number of comments to retrieve.
+   * @returns The list of comments.
+   */
+  async listByAuthor (authorId: number, limit: number): Promise<Comment[]> {
+    return await this.list({ authorId, limit })
+  }
+
+  /**
+   * Retrieves all comments for a specific post.
+   *
+   * @param postId - The ID of the post whose comments are being retrieved.
+   * @param limit - The number of comments to retrieve.
+   * @returns The list of comments.
+   */
+  async listByPost (postId: number, limit: number): Promise<Comment[]> {
+    return await this.list({ postId, limit })
+  }
+
+  /**
+   * Finds a comment by its ID.
+   *
+   * @param commentId - The ID of the comment to retrieve.
+   * @returns The comment or `undefined` if not found.
+   */
+  async findById (commentId: number): Promise<Comment | undefined> {
+    return await this.database
+      .select(this.selectWithAuthor())
+      .from(comments)
+      .innerJoin(users, eq(comments.authorId, users.id))
+      .where(eq(comments.id, commentId))
+      .get() as Comment | undefined
+  }
+
+  /**
+   * Creates a new comment.
+   *
+   * @param comment - The comment to create.
+   * @returns The ID of the created comment.
+   */
+  async create (comment: CommentCreateModel): Promise<bigint | undefined> {
+    const result = await this.database.insert(comments).values(comment)
+    return result.lastInsertRowid
+  }
+
+  /**
+   * 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.
+   */
+  async update (commentId: number, comment: Partial<CommentModel>): Promise<Comment | undefined> {
+    return await this.database
+      .update(comments)
+      .set(comment)
+      .where(eq(comments.id, commentId))
+      .returning(this.selectWithAuthor())
+      .get() as Comment | undefined
+  }
+
+  /**
+   * Deletes a comment by its ID.
+   *
+   * @param commentId - The ID of the comment to delete.
+   * @returns `true` if the comment was deleted, otherwise `false`.
+   */
+  async delete (commentId: number): Promise<boolean> {
+    const result = await this.database.delete(comments).where(eq(comments.id, commentId)).run()
+    return isNotEmpty<bigint>(result.lastInsertRowid) && result.lastInsertRowid > 0
+  }
+
+  /**
+   * Selects comments with author and post information.
+   */
+  private selectWithAuthor (): Record<string, any> {
+    return {
+      id: comments.id,
+      postId: comments.postId,
+      content: comments.content,
+      createdAt: comments.createdAt,
+      author: {
+        id: users.id,
+        name: users.name,
+        email: users.email,
+        createdAt: users.createdAt,
+        updatedAt: users.updatedAt
+      }
+    }
+  }
+}

package/full-service-declarative/app/repositories/PostRepository.ts

@@ -0,0 +1,138 @@
+import { desc, eq } from 'drizzle-orm'
+import { posts, users } from '../database/schema'
+import { isNotEmpty, Stone } from '@stone-js/core'
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+import { Post, PostCreateModel, PostModel } from '../models/Post'
+
+/**
+ * Post Repository Options
+ */
+export interface PostRepositoryOptions {
+  database: LibSQLDatabase
+}
+
+/**
+ * Post Repository
+ *
+ * Manages post-related database operations.
+ */
+@Stone({ alias: 'postRepository' })
+export class PostRepository {
+  private readonly database: LibSQLDatabase
+
+  /**
+   * Create a new instance of PostRepository
+   *
+   * @param options - The options to create the repository
+   */
+  constructor ({ database }: PostRepositoryOptions) {
+    this.database = database
+  }
+
+  /**
+   * Retrieves a list of posts with optional filtering and sorting.
+   *
+   * @param options - Optional filters (authorId, limit, orderBy).
+   * @returns The list of posts.
+   */
+  async list (options?: { authorId?: number, limit?: number }): Promise<Post[]> {
+    const query = this
+      .database
+      .select(this.selectWithAuthor())
+      .from(posts)
+      .innerJoin(users, eq(posts.authorId, users.id))
+
+    if (options?.authorId !== undefined) {
+      await query.where(eq(posts.authorId, options.authorId))
+    }
+
+    await query.orderBy(desc(posts.createdAt))
+
+    if (options?.limit !== undefined) {
+      await query.limit(options.limit)
+    }
+
+    return await query.all() as Post[]
+  }
+
+  /**
+   * Retrieves all posts created by a specific user.
+   *
+   * @param user - The user whose posts are being retrieved.
+   * @param limit - The number of posts to retrieve.
+   * @returns The list of posts.
+   */
+  async listByAuthor (authorId: number, limit: number): Promise<Post[]> {
+    return await this.list({ authorId, limit })
+  }
+
+  /**
+   * Finds a post by its ID.
+   *
+   * @param postId - The ID of the post to retrieve.
+   * @returns The post or `undefined` if not found.
+   */
+  async findById (postId: number): Promise<Post | undefined> {
+    return await this
+      .database
+      .select(this.selectWithAuthor())
+      .from(posts)
+      .innerJoin(users, eq(posts.authorId, users.id))
+      .where(eq(posts.id, postId))
+      .get() as Post | undefined
+  }
+
+  /**
+   * Creates a new post.
+   *
+   * @param post - The post to create.
+   * @returns The ID of the created post.
+   */
+  async create (post: PostCreateModel): Promise<bigint | undefined> {
+    const result = await this.database.insert(posts).values(post)
+    return result.lastInsertRowid
+  }
+
+  /**
+   * Updates a post by its ID.
+   *
+   * @param postId - The ID of the post to update.
+   * @param post - The updated post data.
+   * @returns The updated post or `undefined` if not found.
+   */
+  async update (postId: number, post: Partial<PostModel>): Promise<boolean> {
+    const result = await this.database.update(posts).set(post).where(eq(posts.id, postId))
+    return isNotEmpty<bigint>(result.lastInsertRowid) && result.lastInsertRowid > 0
+  }
+
+  /**
+   * Deletes a post by its ID.
+   *
+   * @param postId - The ID of the post to delete.
+   * @returns `true` if the post was deleted, otherwise `false`.
+   */
+  async delete (postId: number): Promise<boolean> {
+    const result = await this.database.delete(posts).where(eq(posts.id, postId)).run()
+    return isNotEmpty<bigint>(result.lastInsertRowid) && result.lastInsertRowid > 0
+  }
+
+  /**
+   * Selects posts with author information.
+   */
+  private selectWithAuthor (): Record<string, any> {
+    return {
+      id: posts.id,
+      title: posts.title,
+      content: posts.content,
+      createdAt: posts.createdAt,
+      updatedAt: posts.updatedAt,
+      author: {
+        id: users.id,
+        name: users.name,
+        email: users.email,
+        createdAt: users.createdAt,
+        updatedAt: users.updatedAt
+      }
+    }
+  }
+}

package/full-service-declarative/app/repositories/SessionRepository.ts

@@ -0,0 +1,123 @@
+import { desc, eq } from 'drizzle-orm'
+import { Stone } from '@stone-js/core'
+import { UserModel } from '../models/User'
+import { Session } from '../models/Session'
+import { sessions } from '../database/schema'
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+
+/**
+ * Session Session Repository Options
+ */
+export interface SessionRepositoryOptions {
+  database: LibSQLDatabase
+}
+
+/**
+ * Session Session Repository
+ *
+ * Manages session session persistence in the database.
+ */
+@Stone({ alias: 'sessionRepository' })
+export class SessionRepository {
+  private readonly database: LibSQLDatabase
+
+  /**
+   * Create a new instance of SessionRepository
+   *
+   * @param options - The options to create the repository
+   */
+  constructor ({ database }: SessionRepositoryOptions) {
+    this.database = database
+  }
+
+  /**
+   * List sessions
+   *
+   * @param limit - The limit of sessions to list
+   * @returns The list of sessions
+   */
+  async list (limit: number): Promise<Session[]> {
+    return await this
+      .database
+      .select()
+      .from(sessions)
+      .orderBy(desc(sessions.createdAt))
+      .limit(limit)
+  }
+
+  /**
+   * List sessions
+   *
+   * @param limit - The limit of sessions to list
+   * @returns The list of sessions
+   */
+  async listByUser (user: UserModel, limit: number): Promise<Session[]> {
+    return await this
+      .database
+      .select()
+      .from(sessions)
+      .where(eq(sessions.userId, user.id))
+      .orderBy(desc(sessions.createdAt))
+      .limit(limit)
+  }
+
+  /**
+   * Find a session by ID
+   *
+   * @param id - The ID of the session to find
+   * @returns The session or undefined if not found
+   */
+  async findById (id: number): Promise<Session | undefined> {
+    const result = await this.database.select().from(sessions).where(eq(sessions.id, id)).get()
+    return result ?? undefined
+  }
+
+  /**
+   * Retrieves the latest session for a given user.
+   *
+   * @param user - The user whose last session is being retrieved.
+   * @returns The latest session or `undefined` if none exists.
+   */
+  async getLatest (user: UserModel): Promise<Session | undefined> {
+    return await this.database
+      .select()
+      .from(sessions)
+      .where(eq(sessions.userId, user.id))
+      .orderBy(desc(sessions.createdAt))
+      .limit(1)
+      .get()
+  }
+
+  /**
+   * Create a session
+   *
+   * @param session - The session to create
+   * @returns The ID of the created session
+   */
+  async create (session: Omit<Session, 'id'>): Promise<Session> {
+    return await this.database.insert(sessions).values(session).returning().get()
+  }
+
+  /**
+   * Update a session
+   *
+   * @param id - The ID of the session to update
+   * @param session - The session data to update
+   * @returns The updated session or undefined if not found
+   */
+  async update (id: number, session: Partial<Session>): Promise<Session | undefined> {
+    const result = await this.database.update(sessions).set(session).where(eq(sessions.id, id)).returning().get()
+    return result ?? undefined
+  }
+
+  /**
+   * Delete a session
+   *
+   * @param id - The ID of the session to delete
+   * @returns `true` if the session was deleted, `false` if the session was not found
+   */
+  async delete (id: number): Promise<boolean> {
+    const result = await this.database.delete(sessions).where(eq(sessions.id, id)).run()
+    return result.rowsAffected > 0
+  }
+}

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

@@ -0,0 +1,99 @@
+import { eq } from 'drizzle-orm'
+import { Stone } from '@stone-js/core'
+import { users } from '../database/schema'
+import { UserModel } from '../models/User'
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+
+/**
+ * User Repository Options
+ */
+export interface UserRepositoryOptions {
+  database: LibSQLDatabase
+}
+
+/**
+ * User Repository
+ *
+ * @Stone() is a decorator that marks a class as a Stone component.
+ * @Stone() Think of it like a Bean in Spring or a Component in Angular.
+ * The alias is required to get benefits of destructuring Dependency Injection.
+ */
+@Stone({ alias: 'userRepository' })
+export class UserRepository {
+  private readonly database: LibSQLDatabase
+
+  /**
+   * Create a new instance of UserRepository
+   *
+   * @param options - The options to create the repository
+   */
+  constructor ({ database }: UserRepositoryOptions) {
+    this.database = database
+  }
+
+  /**
+   * List users
+   *
+   * @param limit - The limit of users to list
+   * @returns The list of users
+   */
+  async list (limit: number): Promise<UserModel[]> {
+    return await this.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 this.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 this.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 this.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 this.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 this.database.delete(users).where(eq(users.id, id)).run()
+    return result.rowsAffected > 0
+  }
+}