@stone-js/starters 0.8.3

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

@@ -0,0 +1,53 @@
+import { defineStone } from '@stone-js/core'
+import { Comment, CommentInput } from '../models/Comment'
+import { ICommentService } from './contracts/ICommentService'
+import { ICommentClient } from '../clients/contracts/ICommentClient'
+
+/**
+ * Comment Service Options
+*/
+export interface CommentServiceOptions {
+  commentClient: ICommentClient
+}
+
+/**
+ * Comment Service
+*/
+export const CommentService = ({ commentClient }: CommentServiceOptions): ICommentService => ({
+  /**
+   * List comments
+   *
+   * @param postId - The id of the post to list comments
+   * @param limit - The limit of comments to list
+   */
+  async list (postId: number, limit: number = 10): Promise<Comment[]> {
+    return await commentClient.list(postId, limit)
+  },
+
+  /**
+   * Create a comment
+   *
+   * @param postId - The id of the post to create the comment for
+   * @param comment - The comment to create
+   */
+  async create (postId: number, comment: CommentInput): Promise<void> {
+    await commentClient.create(postId, comment)
+  },
+
+  /**
+   * Delete a comment
+   *
+   * @param id - The id of the comment to delete
+   */
+  async delete (id: number): Promise<void> {
+    await commentClient.delete(id)
+  }
+})
+
+/**
+ * Comment Service blueprint.
+ *
+ * The alias is required to get benefits of desctructuring Dependency Injection.
+ * And because the front-end class will be minified, we need to use alias to keep the class name.
+*/
+export const CommentServiceBlueprint = defineStone(CommentService, { alias: 'commentService' })

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

@@ -0,0 +1,102 @@
+import { defineService } from '@stone-js/core'
+import { Post, PostInput } from '../models/Post'
+import { IPostService } from './contracts/IPostService'
+import { IPostClient } from '../clients/contracts/IPostClient'
+import { PostNotFoundError } from '../errors/PostNotFoundError'
+
+/**
+ * Post Service Options
+*/
+export interface PostServiceOptions {
+  postClient: IPostClient
+}
+
+/**
+ * Post Service
+*/
+export const PostService = ({ postClient }: PostServiceOptions): IPostService => ({
+  /**
+   * List posts
+   *
+   * @param limit - The limit of posts to list
+   */
+  async list (limit: number = 10): Promise<Post[]> {
+    return await postClient.list(limit)
+  },
+
+  /**
+   * List posts by author
+   *
+   * @param id - The id of the author to list posts
+   * @param limit - The limit of posts to list
+   */
+  async listbyAuthor (id: number, limit: number = 10): Promise<Post[]> {
+    return await postClient.listByAuthor(id, limit)
+  },
+
+  /**
+   * Find a post
+   *
+   * @param conditions - The conditions to find the post
+   * @returns The found post
+   */
+  async find (conditions: Record<string, any>): Promise<Post> {
+    try {
+      return await postClient.find(conditions.id)
+    } catch (error: any) {
+      if (error.status === 404) {
+        throw new PostNotFoundError(error.message, { cause: error })
+      } else {
+        throw error
+      }
+    }
+  },
+
+  /**
+   * Find a post by key
+   *
+   * @param key - The key to find the post
+   * @param value - The value to find the post
+   * @returns The found post
+   * @throws PostNotFoundError
+   */
+  async findBy (key: string, value: string): Promise<Post | undefined> {
+    return await this.find({ [key]: value })
+  },
+
+  /**
+   * Create a post
+   *
+   * @param post - The post to create
+   */
+  async create (post: PostInput): Promise<Post> {
+    return await postClient.create(post)
+  },
+
+  /**
+   * Update a post
+   *
+   * @param id - The id of the post to update
+   * @param post - The post data to update
+   */
+  async update (id: number, post: PostInput): Promise<Post> {
+    return await postClient.update(id, post)
+  },
+
+  /**
+   * Delete a post
+   *
+   * @param id - The id of the post to delete
+   */
+  async delete (id: number): Promise<void> {
+    await postClient.delete(id)
+  }
+})
+
+/**
+ * Post Service Blueprint
+ *
+ * The alias is required to get benefits of desctructuring Dependency Injection.
+ * And because the front-end class will be minified, we need to use alias to keep the class name.
+ */
+export const PostServiceBlueprint = defineService(PostService, { alias: 'postService', isFactory: true })

package/full-react-imperative/app/services/SecurityService.ts

@@ -0,0 +1,72 @@
+import { defineService } from '@stone-js/core'
+import { ITokenService } from './contracts/ITokenService'
+import { ISecurityService } from './contracts/ISecurityService'
+import { ISecurityClient } from '../clients/contracts/ISecurityClient'
+import { UserChangePassword, UserLogin, UserRegister } from '../models/User'
+
+/**
+ * Security Service Options
+*/
+export interface SecurityServiceOptions {
+  tokenService: ITokenService
+  securityClient: ISecurityClient
+}
+
+/**
+ * Security Service
+*/
+export const SecurityService = ({ tokenService, securityClient }: SecurityServiceOptions): ISecurityService => ({
+  /**
+   * Login a user
+   *
+   * @param user - The user to login
+   * @returns The user token
+  */
+  async login (user: UserLogin): Promise<void> {
+    const token = await securityClient.login(user)
+    tokenService.saveToken(token)
+  },
+
+  /**
+   * Logout a user
+  */
+  async logout (): Promise<void> {
+    await securityClient.logout()
+    tokenService.removeToken()
+  },
+
+  /**
+   * Register a user
+   *
+   * @param user - The user to register
+  */
+  async register (user: UserRegister): Promise<void> {
+    await securityClient.register(user)
+  },
+
+  /**
+   * Change the user password
+   *
+   * @param password - The password to change
+  */
+  async changePassword (password: UserChangePassword): Promise<void> {
+    await securityClient.changePassword(password)
+  },
+
+  /**
+   * Check if the user is authenticated
+   *
+   * @returns True if the user is authenticated, false otherwise
+   */
+  isAuthenticated (): boolean {
+    return tokenService.isAuthenticated()
+  }
+})
+
+/**
+ * Security Service Blueprint
+ *
+ * The alias is required to get benefits of desctructuring Dependency Injection.
+ * And because the front-end class will be minified, we need to use alias to keep the class name.
+*/
+export const SecurityServiceBlueprint = defineService(SecurityService, { alias: 'securityService', isFactory: true })

package/full-react-imperative/app/services/TokenService.ts

@@ -0,0 +1,108 @@
+import { Axios } from 'axios'
+import { UserToken } from '../models/User'
+import { ReactIncomingEvent } from '@stone-js/use-react'
+import { ITokenService } from './contracts/ITokenService'
+import { defineService, IContainer, isNotEmpty } from '@stone-js/core'
+
+/**
+ * Token Service Options
+*/
+export interface TokenServiceOptions {
+  axios: Axios
+  container: IContainer
+}
+
+/**
+ * Token Service
+*/
+export const TokenService = ({ container, axios }: TokenServiceOptions): ITokenService => ({
+  /**
+   * Refresh the user token
+  */
+  async refresh (): Promise<void> {
+    const headers = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${String(this.getAccessToken())}`
+    }
+    const response = await axios.post<UserToken>('/refresh', {}, { headers })
+
+    this.saveToken(response.data)
+  },
+
+  /**
+   * Set the token
+   *
+   * The event must be resolved on demand
+   * because the event is not available at the time of service creation.
+   * The event is available only when the request is made.
+   *
+   * @param token - The token to set
+  */
+  saveToken (token: UserToken): void {
+    container.make<ReactIncomingEvent>('event').cookies.add(
+      'token',
+      { ...token, createdAt: Date.now() },
+      {
+        path: '/',
+        secure: true,
+        httpOnly: false,
+        maxAge: token.expiresIn
+      }
+    )
+  },
+
+  /**
+   * Remove the token
+  */
+  removeToken (): void {
+    container.make<ReactIncomingEvent>('event').cookies.remove(
+      'token',
+      {
+        path: '/',
+        secure: true,
+        httpOnly: false
+      }
+    )
+  },
+
+  /**
+   * Get the token
+   *
+   * The event must be resolved on demand
+   * because the event is not available at the time of service creation.
+   * The event is available only when the request is made.
+   *
+   * @returns The token
+  */
+  getToken (): UserToken | undefined {
+    return container.make<ReactIncomingEvent>('event').cookies.getValue('token')
+  },
+
+  /**
+   * Get the access token
+   *
+   * @returns The access token
+   */
+  getAccessToken (): string | undefined {
+    return this.getToken()?.accessToken
+  },
+
+  /**
+   * Check if the user is authenticated
+   *
+   * @returns True if the user is authenticated, false otherwise
+   */
+  isAuthenticated (): boolean {
+    const token = this.getToken()
+    return isNotEmpty<UserToken>(token) && (token.createdAt + (token.expiresIn * 1000)) > Date.now()
+  }
+})
+
+/**
+ * Token Service Blueprint
+ *
+ * The alias is required to get benefits of desctructuring Dependency Injection.
+ * And because the front-end class will be minified, we need to use alias to keep the class name.
+ */
+export const TokenServiceBlueprint = defineService(TokenService, { alias: 'tokenService', isFactory: true })

package/full-react-imperative/app/services/UserService.ts

@@ -0,0 +1,115 @@
+import { UserEvent } from '../events/UserEvent'
+import { User, UserInput } from '../models/User'
+import { ReactRuntime } from '@stone-js/use-react'
+import { IUserService } from './contracts/IUserService'
+import { defineService, EventEmitter } from '@stone-js/core'
+import { IUserClient } from '../clients/contracts/IUserClient'
+import { UserNotFoundError } from '../errors/UserNotFoundError'
+
+/**
+ * User Service Options
+*/
+export interface UserServiceOptions {
+  userClient: IUserClient
+  reactRuntime: ReactRuntime
+  eventEmitter: EventEmitter
+}
+
+/**
+ * User Service
+*/
+export const UserService = ({ userClient, reactRuntime, eventEmitter }: UserServiceOptions): IUserService => {
+  return {
+    /**
+     * List users
+     *
+     * @param limit - The limit of users to list
+     */
+    async list (limit: number = 10): Promise<User[]> {
+      return await userClient.list(limit)
+    },
+
+    /**
+     * Get the current user
+     */
+    async current (): Promise<User> {
+      return await userClient.currentUser()
+    },
+
+    /**
+     * Find a user
+     *
+     * @param conditions - The conditions to find the user
+     * @returns The found user
+     */
+    async find (conditions: Record<string, any>): Promise<User> {
+      try {
+        return await userClient.find(conditions.id)
+      } catch (error: any) {
+        if (error.status === 404) {
+          throw new UserNotFoundError(error.message, { cause: error })
+        } else {
+          throw error
+        }
+      }
+    },
+
+    /**
+     * Find a user by key
+     *
+     * @param key - The key to find the user
+     * @param value - The value to find the user
+     * @returns The found user
+     * @throws UserNotFoundError
+     */
+    async findBy (key: string, value: any): Promise<User | undefined> {
+      return await reactRuntime.snapshot(`user-${String(key)}-${String(value)}`, async () => await this.find({ [key]: value }))
+    },
+
+    /**
+     * Create a user
+     *
+     * @param user - The user to create
+     */
+    async create (user: UserInput): Promise<void> {
+      await eventEmitter.emit(new UserEvent(user))
+      await userClient.create(user)
+    },
+
+    /**
+     * Update the current user
+     *
+     * @param user - The user data to update
+     */
+    async updateCurrent (user: UserInput): Promise<User> {
+      return await userClient.updateCurrent(user)
+    },
+
+    /**
+     * Update a user
+     *
+     * @param id - The id of the user to update
+     * @param user - The user data to update
+     */
+    async update (id: number, user: UserInput): Promise<User> {
+      return await userClient.update(id, user)
+    },
+
+    /**
+     * Delete a user
+     *
+     * @param id - The id of the user to delete
+     */
+    async delete (id: number): Promise<void> {
+      await userClient.delete(id)
+    }
+  }
+}
+
+/**
+ * User Service Blueprint
+ *
+ * The alias is required to get benefits of desctructuring Dependency Injection.
+ * And because the front-end class will be minified, we need to use alias to keep the class name.
+ */
+export const UserServiceBlueprint = defineService(UserService, { alias: 'userService', isFactory: true })

package/full-react-imperative/app/services/contracts/ICommentService.ts

@@ -0,0 +1,30 @@
+import { Comment, CommentInput } from '../../models/Comment'
+
+/**
+ * Comment Service contract
+ */
+export interface ICommentService {
+  /**
+   * List comments for a given post.
+   *
+   * @param postId - The ID of the post to list comments for.
+   * @param limit - Optional number of comments to return (default: 10).
+   * @returns The list of comments.
+   */
+  list: (postId: number, limit?: number) => Promise<Comment[]>
+
+  /**
+   * Create a new comment for a post.
+   *
+   * @param postId - The ID of the post.
+   * @param comment - The comment data.
+   */
+  create: (postId: number, comment: CommentInput) => Promise<void>
+
+  /**
+   * Delete a comment by its ID.
+   *
+   * @param id - The ID of the comment to delete.
+   */
+  delete: (id: number) => Promise<void>
+}

package/full-react-imperative/app/services/contracts/IPostService.ts

@@ -0,0 +1,65 @@
+import { Post, PostInput } from '../../models/Post'
+
+/**
+ * Post Service contract
+ */
+export interface IPostService {
+  /**
+   * List posts.
+   *
+   * @param limit - Optional limit of posts to list (default: 10).
+   * @returns The list of posts.
+   */
+  list: (limit?: number) => Promise<Post[]>
+
+  /**
+   * List posts by author.
+   *
+   * @param id - The author ID.
+   * @param limit - Optional limit of posts (default: 10).
+   * @returns The list of posts.
+   */
+  listbyAuthor: (id: number, limit?: number) => Promise<Post[]>
+
+  /**
+   * Find a post by conditions (e.g., ID).
+   *
+   * @param conditions - Key-value map to identify the post (e.g., `{ id: 42 }`).
+   * @returns The found post.
+   * @throws PostNotFoundError if not found.
+   */
+  find: (conditions: Record<string, any>) => Promise<Post>
+
+  /**
+   * Find a post by a specific key and value.
+   *
+   * @param key - The key to filter by.
+   * @param value - The value to match.
+   * @returns The post or throws PostNotFoundError.
+   */
+  findBy: (key: string, value: string) => Promise<Post | undefined>
+
+  /**
+   * Create a post.
+   *
+   * @param post - The post data to create.
+   * @returns The created post.
+   */
+  create: (post: PostInput) => Promise<Post>
+
+  /**
+   * Update a post.
+   *
+   * @param id - The ID of the post to update.
+   * @param post - The post data to update.
+   * @returns The updated post.
+   */
+  update: (id: number, post: PostInput) => Promise<Post>
+
+  /**
+   * Delete a post by ID.
+   *
+   * @param id - The ID of the post to delete.
+   */
+  delete: (id: number) => Promise<void>
+}

package/full-react-imperative/app/services/contracts/ISecurityService.ts

@@ -0,0 +1,39 @@
+import { UserLogin, UserRegister, UserChangePassword } from '../../models/User'
+
+/**
+ * Security Service contract
+ */
+export interface ISecurityService {
+  /**
+   * Login a user and store their token.
+   *
+   * @param user - The user login credentials.
+   */
+  login: (user: UserLogin) => Promise<void>
+
+  /**
+   * Logout the user and clear the token.
+   */
+  logout: () => Promise<void>
+
+  /**
+   * Register a new user.
+   *
+   * @param user - The user registration data.
+   */
+  register: (user: UserRegister) => Promise<void>
+
+  /**
+   * Change the user's password.
+   *
+   * @param password - The password payload.
+   */
+  changePassword: (password: UserChangePassword) => Promise<void>
+
+  /**
+   * Check if the user is currently authenticated.
+   *
+   * @returns `true` if authenticated, `false` otherwise.
+   */
+  isAuthenticated: () => boolean
+}

package/full-react-imperative/app/services/contracts/ITokenService.ts

@@ -0,0 +1,44 @@
+import { UserToken } from '../../models/User'
+
+/**
+ * Token Service contract
+ */
+export interface ITokenService {
+  /**
+   * Refresh the user token by making a call to the refresh endpoint.
+   */
+  refresh: () => Promise<void>
+
+  /**
+   * Save the token in the cookies.
+   *
+   * @param token - The token to store.
+   */
+  saveToken: (token: UserToken) => void
+
+  /**
+   * Remove the token from cookies.
+   */
+  removeToken: () => void
+
+  /**
+   * Get the full token object from cookies.
+   *
+   * @returns The stored token, or `undefined` if not found.
+   */
+  getToken: () => UserToken | undefined
+
+  /**
+   * Get only the access token string from the stored token.
+   *
+   * @returns The access token string, or `undefined`.
+   */
+  getAccessToken: () => string | undefined
+
+  /**
+   * Check if the user is currently authenticated based on token expiry.
+   *
+   * @returns `true` if the user is authenticated, otherwise `false`.
+   */
+  isAuthenticated: () => boolean
+}

package/full-react-imperative/app/services/contracts/IUserService.ts

@@ -0,0 +1,70 @@
+import { User, UserInput } from '../../models/User'
+
+/**
+ * User Service contract
+ */
+export interface IUserService {
+  /**
+   * List users.
+   *
+   * @param limit - The number of users to list (default: 10).
+   * @returns The list of users.
+   */
+  list: (limit?: number) => Promise<User[]>
+
+  /**
+   * Get the currently authenticated user.
+   *
+   * @returns The current user.
+   */
+  current: () => Promise<User>
+
+  /**
+   * Find a user by conditions (e.g., by ID).
+   *
+   * @param conditions - Conditions to identify the user (e.g., `{ id: number }`).
+   * @returns The found user.
+   * @throws UserNotFoundError if the user is not found.
+   */
+  find: (conditions: Record<string, any>) => Promise<User>
+
+  /**
+   * Find a user by key-value pair with snapshot caching.
+   *
+   * @param key - The key to filter by (e.g., `"email"`).
+   * @param value - The value to match.
+   * @returns The found user or throws UserNotFoundError.
+   */
+  findBy: (key: string, value: any) => Promise<User | undefined>
+
+  /**
+   * Create a new user.
+   *
+   * @param user - The user data to create.
+   */
+  create: (user: UserInput) => Promise<void>
+
+  /**
+   * Update the currently authenticated user.
+   *
+   * @param user - The updated user data.
+   * @returns The updated user.
+   */
+  updateCurrent: (user: UserInput) => Promise<User>
+
+  /**
+   * Update a user by ID.
+   *
+   * @param id - The ID of the user to update.
+   * @param user - The updated user data.
+   * @returns The updated user.
+   */
+  update: (id: number, user: UserInput) => Promise<User>
+
+  /**
+   * Delete a user by ID.
+   *
+   * @param id - The ID of the user to delete.
+   */
+  delete: (id: number) => Promise<void>
+}