@stone-js/starters 0.8.3

package/full-service-imperative/app/middleware/AuthMiddleware.ts

@@ -0,0 +1,44 @@
+import { ISecurityService } from '../services/contracts/ISecurityService'
+import { IncomingHttpEvent, OutgoingHttpResponse } from '@stone-js/http-core'
+import { defineMiddleware, FunctionalMiddleware, NextMiddleware } from '@stone-js/core'
+
+/**
+ * Auth middleware Options
+*/
+export interface AuthMiddlewareOptions {
+  securityService: ISecurityService
+}
+
+/**
+ * Factory Auth middleware
+ */
+export function factoryAuthMiddleware ({ securityService }: AuthMiddlewareOptions): FunctionalMiddleware<IncomingHttpEvent, OutgoingHttpResponse> {
+  /**
+   * Handle the incoming event
+   *
+   * @param event - The incoming event
+   * @param next - The next middleware
+   * @returns The response
+   */
+  return async function (
+    event: IncomingHttpEvent,
+    next: NextMiddleware<IncomingHttpEvent, OutgoingHttpResponse>,
+    excludes: string[] = []
+  ): Promise<OutgoingHttpResponse> {
+    const isOptionsRequest = event.isMethod('OPTIONS')
+    const isExcludedPath = excludes.includes(event.pathname)
+
+    if (!isExcludedPath && !isOptionsRequest) {
+      const token = event.get<string>('Authorization', '').replace('Bearer ', '')
+      const user = await securityService.authenticate(token, event.ip, event.userAgent)
+      event.setUserResolver(() => user)
+    }
+
+    return await next(event)
+  }
+}
+
+/**
+ * Auth middleware
+ */
+export const AuthMiddleware = defineMiddleware(factoryAuthMiddleware, { isFactory: true, global: true, params: [['/login', '/register']] })

package/full-service-imperative/app/models/Comment.ts

@@ -0,0 +1,38 @@
+import { User } from './User'
+
+/**
+ * Comment Interface
+*/
+export interface CommentModel {
+  id: number
+  content: string
+  postId: number
+  authorId: number
+  createdAt: number
+}
+
+/**
+ * Comment Create Model Interface
+*/
+export interface CommentCreateModel extends Omit<CommentModel, 'id'> {}
+
+/**
+ * Comment Interface
+*/
+export interface Comment extends Omit<CommentModel, 'authorId'> {
+  author: User
+}
+
+/**
+ * Comment Create Request Interface
+ * Represents a comment create request resource.
+*/
+export interface CommentCreateRequest {
+  content: string
+}
+
+/**
+ * Comment Response Interface
+ * Represents a comment response resource.
+*/
+export interface CommentResponse extends Comment {}

package/full-service-imperative/app/models/Post.ts

@@ -0,0 +1,50 @@
+import { User } from './User'
+
+/**
+ * Post Model Interface
+*/
+export interface PostModel {
+  id: number
+  title: string
+  content: string
+  authorId: number
+  createdAt: number
+  updatedAt: number
+}
+
+/**
+ * Post Create Model Interface
+*/
+export interface PostCreateModel extends Omit<PostModel, 'id'> {}
+
+/**
+ * Post Interface
+*/
+export interface Post extends Omit<PostModel, 'authorId'> {
+  author: User
+}
+
+/**
+ * Post Create Request Interface
+ * Represents a post create request resource.
+*/
+export interface PostCreateRequest {
+  title: string
+  content: string
+}
+
+/**
+ * Post Update Request Interface
+ * Represents a post update request resource.
+*/
+export interface PostUpdateRequest {
+  id: number
+  title: string
+  content: string
+}
+
+/**
+ * Post Response Interface
+ * Represents a post response resource.
+*/
+export interface PostResponse extends Post {}

package/full-service-imperative/app/models/Session.ts

@@ -0,0 +1,14 @@
+/**
+ * Session Interface
+*/
+export interface Session {
+  ip: string
+  id: number
+  uuid: string
+  userId: number
+  createdAt: number
+  expiresAt: number
+  lastActivityAt: number
+  closedAt?: number | null
+  userAgent?: string | null
+}

package/full-service-imperative/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-imperative/app/providers/DrizzleServiceProvider.ts

@@ -0,0 +1,56 @@
+import {
+  IContainer,
+  IServiceProvider,
+  defineHookListener,
+  defineServiceProvider,
+  AdapterHookListenerContext
+} from '@stone-js/core'
+import { Config } from '@libsql/client'
+import { drizzle } from 'drizzle-orm/libsql'
+import { getClient, closeClient, createClient } from '../database/DatabaseClient'
+
+/**
+ * Factory 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
+ */
+export function factoryDrizzleServiceProvider (container: IContainer): IServiceProvider {
+  return {
+    /**
+     * Register services to the container
+     */
+    register (): void {
+      container
+        .instanceIf('drizzle', drizzle(getClient()))
+        .alias('drizzle', ['db', 'database'])
+    }
+  }
+}
+
+/**
+ * On start hook that will be called
+ * once when the application starts
+ *
+ * @param context - The adapter hook listener context
+ */
+export const startDatabase = defineHookListener(({ blueprint }: AdapterHookListenerContext): void => {
+  createClient(
+    blueprint.get<Config>('database', { url: 'file:local.db' })
+  )
+}, { name: 'onStart' })
+
+/**
+ * On stop hook that will be called
+ * once when the application stops
+ *
+ * @param context - The adapter hook listener context
+ */
+export const closeDatabase = defineHookListener((): void => {
+  closeClient()
+}, { name: 'onStop' })
+
+/**
+ * Drizzle Service Provider
+ */
+export const DrizzleServiceProvider = defineServiceProvider(factoryDrizzleServiceProvider)

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

@@ -0,0 +1,148 @@
+import { desc, eq } from 'drizzle-orm'
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+import { comments, users } from '../database/schema'
+import { defineStone, isNotEmpty } from '@stone-js/core'
+import { ICommentRepository } from './contracts/ICommentRepository'
+import { Comment, CommentCreateModel, CommentModel } from '../models/Comment'
+
+/**
+ * Comment Repository Options
+ */
+export interface CommentRepositoryOptions {
+  database: LibSQLDatabase
+}
+
+/**
+ * Factory Comment Repository
+ */
+export function factoryCommentRepository ({ database }: CommentRepositoryOptions): ICommentRepository {
+  return {
+    /**
+     * 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 = 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 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 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 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 database.delete(comments).where(eq(comments.id, commentId)).run()
+      return isNotEmpty<bigint>(result.lastInsertRowid) && result.lastInsertRowid > 0
+    },
+
+    /**
+     * Selects comments with author and post information.
+     */
+    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
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Comment Repository
+ */
+export const CommentRepository = defineStone(factoryCommentRepository, { isFactory: true, singleton: true, alias: 'commentRepository' })

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

@@ -0,0 +1,130 @@
+import { desc, eq } from 'drizzle-orm'
+import { posts, users } from '../database/schema'
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+import { defineStone, isNotEmpty } from '@stone-js/core'
+import { IPostRepository } from './contracts/IPostRepository'
+import { Post, PostCreateModel, PostModel } from '../models/Post'
+
+/**
+ * Post Repository Options
+ */
+export interface PostRepositoryOptions {
+  database: LibSQLDatabase
+}
+
+/**
+ * Factory Post Repository
+ */
+export function factoryPostRepository ({ database }: PostRepositoryOptions): IPostRepository {
+  return {
+    /**
+     * 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 = 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 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 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 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 database.delete(posts).where(eq(posts.id, postId)).run()
+      return isNotEmpty<bigint>(result.lastInsertRowid) && result.lastInsertRowid > 0
+    },
+
+    /**
+     * Selects posts with author information.
+     */
+    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
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Post Repository
+ */
+export const PostRepository = defineStone(factoryPostRepository, { isFactory: true, singleton: true, alias: 'postRepository' })

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

@@ -0,0 +1,115 @@
+import { desc, eq } from 'drizzle-orm'
+import { UserModel } from '../models/User'
+import { Session } from '../models/Session'
+import { defineStone } from '@stone-js/core'
+import { sessions } from '../database/schema'
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+import { ISessionRepository } from './contracts/ISessionRepository'
+
+/**
+ * Session Session Repository Options
+ */
+export interface SessionRepositoryOptions {
+  database: LibSQLDatabase
+}
+
+/**
+ * Factory Session Repository
+ */
+export function factorySessionRepository ({ database }: SessionRepositoryOptions): ISessionRepository {
+  return {
+    /**
+     * List sessions
+     *
+     * @param limit - The limit of sessions to list
+     * @returns The list of sessions
+     */
+    async list (limit: number): Promise<Session[]> {
+      return await 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 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 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 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 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 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 database.delete(sessions).where(eq(sessions.id, id)).run()
+      return result.rowsAffected > 0
+    }
+  }
+}
+
+/**
+ * Session Repository
+ */
+export const SessionRepository = defineStone(factorySessionRepository, { isFactory: true, singleton: true, alias: 'sessionRepository' })