@stone-js/starters 0.8.3

package/full-react-imperative/app/Application.ts

@@ -0,0 +1,79 @@
+import { routerBlueprint } from '@stone-js/router'
+import { browserAdapterBlueprint } from '@stone-js/browser-adapter'
+import { nodeHttpAdapterBlueprint } from '@stone-js/node-http-adapter'
+import { nodeConsoleAdapterBlueprint } from '@stone-js/node-cli-adapter'
+import { defineStoneReactApp, ReactLifecycleHookType } from '@stone-js/use-react'
+import { defineHookListeners, IBlueprint, IContainer, ILogger, LogLevel, Promiseable } from '@stone-js/core'
+
+/**
+ * Start the application
+ * Run at each cold start.
+ * At this point, you only have access to the blueprint.
+ * Because the container is not yet created.
+ */
+export function onStart ({ blueprint }: { blueprint: IBlueprint }): void {
+  const AppName = blueprint.get<string>('stone.name')
+  console.log(`${String(AppName)}'s Application is starting`)
+}
+
+/**
+ * Prepare the application
+ * Run at each warm start in server context.
+ * And at each cold start in browser context.
+ */
+export function onInit ({ logger }: { logger: ILogger }): Promiseable<void> {
+  logger.info('Application is initializing')
+}
+
+/**
+ * Before handle the incoming event
+ */
+export function onHandlingEvent ({ logger }: { logger: ILogger }): Promiseable<void> {
+  logger.info('Before handle incoming event')
+}
+
+/**
+ * Before prepare the react page
+ */
+export function onPreparingPage ({ container }: { container: IContainer }): Promiseable<void> {
+  container.make<ILogger>('logger').info('Before prepare the react page')
+}
+
+/**
+ * After the incoming event has been processed
+ */
+export function onProcessingKernelMiddleware ({ pipe }: { pipe: any }): Promiseable<void> {
+  console.info('Kernel middleware is processing', pipe.module.name)
+}
+
+/**
+ * After the platform event has been sent to the user
+ */
+export function onTerminate ({ logger }: { logger: ILogger }): Promiseable<void> {
+  logger.info('The event has been sent to the user')
+}
+
+/**
+ * Stone-React Application
+ */
+export const MyStoneReactApp = defineStoneReactApp(
+  { name: 'My Stone', logger: { level: LogLevel.DEBUG } },
+  [
+    routerBlueprint,
+    browserAdapterBlueprint,
+    nodeHttpAdapterBlueprint,
+    nodeConsoleAdapterBlueprint
+  ]
+)
+
+/**
+ * Hooks Listeners Blueprint
+ */
+export const HooksListenersBlueprint = defineHookListeners<ReactLifecycleHookType>({
+  onInit: [onInit],
+  onStart: [onStart],
+  onTerminate: [onTerminate],
+  onPreparingPage: [onPreparingPage],
+  onHandlingEvent: [onHandlingEvent],
+  onProcessingKernelMiddleware: [onProcessingKernelMiddleware]
+})

package/full-react-imperative/app/clients/AxiosClient.ts

@@ -0,0 +1,124 @@
+import { isEmpty, isNotEmpty } from '@stone-js/core'
+import { IAxiosClient } from './contracts/IAxiosClient'
+import { UnauthorizedError } from '../errors/UnauthorizedError'
+import { isServer, ReactIncomingEvent } from '@stone-js/use-react'
+import { ITokenService } from '../services/contracts/ITokenService'
+import { AxiosError, Axios, AxiosRequestConfig, AxiosResponse } from 'axios'
+
+/**
+ * Axios Client Options
+ */
+export interface AxiosClientOptions {
+  axios: Axios
+  event: ReactIncomingEvent
+  tokenService: ITokenService
+}
+
+/**
+ * Axios Client
+ */
+export const AxiosClient = ({ axios, event, tokenService }: AxiosClientOptions): IAxiosClient => {
+  return {
+    /**
+     * Make a request
+     *
+     * @param url - The URL to request
+     * @param data - The data to send
+     * @param options - The request options
+     * @returns The response data
+     * @throws NotAuthenticateError
+     * @throws AxiosError
+     */
+    async request<T = any, R = AxiosResponse<T>, D = any>(url: string, payload?: D, options?: AxiosRequestConfig<D>): Promise<T> {
+      try {
+        const token = await this.getAccessToken()
+        const headers: Record<string, any> = options?.headers ?? {}
+        // const validateStatus = (status: number) => status >= 200 && status < 500
+
+        if (isServer()) { headers['User-Agent'] = event.userAgent }
+
+        headers.Accept ??= 'application/json'
+        headers['Content-Type'] ??= 'application/json'
+        headers.Authorization = isEmpty(token) ? '' : `Bearer ${token}`
+
+        return (await axios.request({ ...options, url, data: payload, headers /* validateStatus */ })).data
+      } catch (error: any) {
+        if (isNotEmpty<AxiosError<R, D>>(error) && error.status === 401) {
+          throw new UnauthorizedError(error.message, { cause: error })
+        } else {
+          throw error
+        }
+      }
+    },
+
+    /**
+     * Make a GET request
+     *
+     * @param url - The URL to request
+     * @param options - The request options
+     * @returns The response data
+     */
+    async get<T = any, R = AxiosResponse<T>, D = any>(url: string, options?: AxiosRequestConfig<D>): Promise<T> {
+      return await this.request<T, R, D>(url, undefined, { ...options, method: 'GET' })
+    },
+
+    /**
+     * Make a POST request
+     *
+     * @param url - The URL to request
+     * @param data - The data to send
+     * @param options - The request options
+     * @returns The response data
+     */
+    async post<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, options?: AxiosRequestConfig<D>): Promise<T> {
+      return await this.request<T, R, D>(url, data, { ...options, method: 'POST' })
+    },
+
+    /**
+     * Make a PUT request
+     *
+     * @param url - The URL to request
+     * @param data - The data to send
+     * @param options - The request options
+     * @returns The response data
+     */
+    async put<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, options?: AxiosRequestConfig<D>): Promise<T> {
+      return await this.request<T, R, D>(url, data, { ...options, method: 'PUT' })
+    },
+
+    /**
+     * Make a PATCH request
+     *
+     * @param url - The URL to request
+     * @param data - The data to send
+     * @param options - The request options
+     * @returns The response data
+     */
+    async patch<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, options?: AxiosRequestConfig<D>): Promise<T> {
+      return await this.request<T, R, D>(url, data, { ...options, method: 'PATCH' })
+    },
+
+    /**
+     * Make a DELETE request
+     *
+     * @param url - The URL to request
+     * @param options - The request options
+     * @returns The response data
+     */
+    async delete<T = any, R = AxiosResponse<T>, D = any>(url: string, options?: AxiosRequestConfig<D>): Promise<T> {
+      return await this.request<T, R, D>(url, undefined, { ...options, method: 'DELETE' })
+    },
+
+    /**
+     * Get the access token
+     *
+     * @returns The access token
+     */
+    async getAccessToken (): Promise<string> {
+      if (isNotEmpty(tokenService.getAccessToken()) && !tokenService.isAuthenticated()) {
+        await tokenService.refresh()
+      }
+      return tokenService.getAccessToken() ?? ''
+    }
+  }
+}

package/full-react-imperative/app/clients/CommentClient.ts

@@ -0,0 +1,57 @@
+import { defineStone } from '@stone-js/core'
+import { IAxiosClient } from './contracts/IAxiosClient'
+import { Comment, CommentInput } from '../models/Comment'
+import { ICommentClient } from './contracts/ICommentClient'
+
+/**
+ * Comment Client Options
+*/
+export interface CommentClientOptions {
+  httpClient: IAxiosClient
+}
+
+/**
+ * Comment Client
+ */
+export const CommentClient = ({ httpClient: client }: CommentClientOptions): ICommentClient => {
+  const path = '/comments'
+
+  return {
+    /**
+     * List comments
+     *
+     * @param postId - The id of the Post to list Comments
+     * @param limit - The limit of Comments to list
+     * @returns The list of Comments
+     */
+    async list (postId: number, limit: number = 10): Promise<Comment[]> {
+      const query = new URLSearchParams({ limit: limit.toString() })
+      return await client.get<Comment[]>(`${String(path)}/posts/${String(postId)}?${String(query)}`)
+    },
+
+    /**
+     * Create a comment
+     *
+     * @param postId - The id of the Post to create the Comment for
+     * @param comment - The Comment to create
+     * @returns The created Comment
+     */
+    async create (postId: number, comment: CommentInput) {
+      return await client.post(`${path}/posts/${postId}`, { ...comment, id: undefined })
+    },
+
+    /**
+     * Delete a comment
+     *
+     * @param id - The id of the Comment to delete
+     */
+    async delete (id: number) {
+      return await client.delete(`${path}/${id}`)
+    }
+  }
+}
+
+/**
+ * Comment Client blueprint.
+*/
+export const CommentClientBlueprint = defineStone(CommentClient, { alias: 'commentClient' })

package/full-react-imperative/app/clients/PostClient.ts

@@ -0,0 +1,86 @@
+import { defineStone } from '@stone-js/core'
+import { Post, PostInput } from '../models/Post'
+import { IPostClient } from './contracts/IPostClient'
+import { IAxiosClient } from './contracts/IAxiosClient'
+
+/**
+ * Post Client Options
+*/
+export interface PostClientOptions {
+  httpClient: IAxiosClient
+}
+
+/**
+ * Post Client
+ */
+export const PostClient = ({ httpClient: client }: PostClientOptions): IPostClient => {
+  const path = '/posts'
+
+  return {
+    /**
+     * List posts
+     *
+     * @param limit - The limit of posts to list
+     * @returns The list of posts
+     */
+    async list (limit: number = 10): Promise<Post[]> {
+      return await client.get<Post[]>(`${path}?limit=${limit}`)
+    },
+
+    /**
+     * List posts by author
+     *
+     * @param id - The id of the author to list posts
+     * @param limit - The limit of posts to list
+     * @returns The list of posts
+     */
+    async listByAuthor (id: number, limit: number = 10): Promise<Post[]> {
+      return await client.get<Post[]>(`${path}/authors/${id}?limit=${limit}`)
+    },
+
+    /**
+     * Find an post
+     *
+     * @param id - The id of the post to find
+     * @returns The found post
+     */
+    async find (id: number): Promise<Post> {
+      return await client.get<Post>(`${path}/${id}`)
+    },
+
+    /**
+     * Create an post
+     *
+     * @param post - The post to create
+     * @returns The created post
+     */
+    async create (post: PostInput) {
+      return await client.post(path, post)
+    },
+
+    /**
+     * Update an post
+     *
+     * @param id - The id of the post to update
+     * @param post - The post to update
+     * @returns The updated post
+     */
+    async update (id: number, post: PostInput) {
+      return await client.patch(`${path}/${id}`, post)
+    },
+
+    /**
+     * Delete an post
+     *
+     * @param id - The id of the post to delete
+     */
+    async delete (id: number) {
+      return await client.delete(`${path}/${id}`)
+    }
+  }
+}
+
+/**
+ * Post Client blueprint.
+*/
+export const PostClientBlueprint = defineStone(PostClient, { alias: 'postClient' })

package/full-react-imperative/app/clients/SecurityClient.ts

@@ -0,0 +1,60 @@
+
+import { Axios } from 'axios'
+import { defineStone } from '@stone-js/core'
+import { IAxiosClient } from './contracts/IAxiosClient'
+import { ISecurityClient } from './contracts/ISecurityClient'
+import { UserChangePassword, UserLogin, UserRegister, UserToken } from '../models/User'
+
+/**
+ * Security Client Options
+*/
+export interface SecurityClientOptions {
+  axios: Axios
+  httpClient: IAxiosClient
+}
+
+/**
+ * Security Client
+ */
+export const SecurityClient = ({ axios, httpClient: client }: SecurityClientOptions): ISecurityClient => {
+  return {
+    /**
+     * Login a user
+     *
+     * @param user - The user to login
+     */
+    async login (user: UserLogin): Promise<UserToken> {
+      return (await axios.post<UserToken>('/login', user)).data
+    },
+
+    /**
+     * Logout a user
+     */
+    async logout (): Promise<void> {
+      await client.post<UserToken>('/logout')
+    },
+
+    /**
+     * Register a user
+     *
+     * @param user - The user to register
+     */
+    async register (user: UserRegister): Promise<void> {
+      await axios.post('/register', user)
+    },
+
+    /**
+     * Change the user password
+     *
+     * @param password - The password to change
+     */
+    async changePassword (password: UserChangePassword): Promise<void> {
+      await client.patch('/change-password', password)
+    }
+  }
+}
+
+/**
+ * Security Client blueprint.
+*/
+export const SecurityClientBlueprint = defineStone(SecurityClient, { alias: 'securityClient' })

package/full-react-imperative/app/clients/UserClient.ts

@@ -0,0 +1,93 @@
+import { defineStone } from '@stone-js/core'
+import { User, UserInput } from '../models/User'
+import { IUserClient } from './contracts/IUserClient'
+import { IAxiosClient } from './contracts/IAxiosClient'
+
+/**
+ * User Client Options
+ */
+export interface UserClientOptions {
+  httpClient: IAxiosClient
+}
+
+/**
+ * User Client
+ */
+export const UserClient = ({ httpClient: client }: UserClientOptions): IUserClient => {
+  const path = '/users'
+
+  return {
+    /**
+     * List users
+     *
+     * @param limit - The limit of users to list
+     * @returns The list of users
+     */
+    async list (limit: number = 10): Promise<User[]> {
+      return await client.get<User[]>(`${path}?limit=${limit}`)
+    },
+
+    /**
+     * Get the current user
+     *
+     * @returns The current user
+     */
+    async currentUser (): Promise<User> {
+      return await client.get<User>(`${path}/me`)
+    },
+
+    /**
+     * Find a user
+     *
+     * @param id - The id of the user to find
+     * @returns The found user
+     */
+    async find (id: number): Promise<User> {
+      return await client.get<User>(`${path}/${id}`)
+    },
+
+    /**
+     * Create a user
+     *
+     * @param user - The user to create
+     */
+    async create (user: UserInput) {
+      return await client.post(path, user)
+    },
+
+    /**
+     * Update the current user
+     *
+     * @param user - The current user
+     * @returns The current user
+     */
+    async updateCurrent (user: UserInput) {
+      return await client.patch(`${path}/me`, user)
+    },
+
+    /**
+     * Update a user
+     *
+     * @param id - The id of the user to update
+     * @param user - The user to update
+     * @returns The updated user
+     */
+    async update (id: number, user: UserInput) {
+      return await client.patch(`${path}/${id}`, user)
+    },
+
+    /**
+     * Delete a user
+     *
+     * @param id - The id of the user to delete
+     */
+    async delete (id: number) {
+      return await client.delete(`${path}/${id}`)
+    }
+  }
+}
+
+/**
+ * User client blueprint.
+*/
+export const UserClientBlueprint = defineStone(UserClient, { alias: 'userClient' })

package/full-react-imperative/app/clients/contracts/IAxiosClient.ts

@@ -0,0 +1,97 @@
+import { AxiosResponse, AxiosRequestConfig } from 'axios'
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+/**
+ * Axios Client contract
+ */
+export interface IAxiosClient {
+  /**
+   * Make a generic HTTP request.
+   *
+   * @param url - The URL to request.
+   * @param payload - Optional request body.
+   * @param options - Axios request configuration.
+   * @returns The response data.
+   * @throws UnauthorizedError
+   * @throws AxiosError
+   */
+  request: <T = any, R = AxiosResponse<T>, D = any>(
+    url: string,
+    payload?: D,
+    options?: AxiosRequestConfig<D>
+  ) => Promise<T>
+
+  /**
+   * Make a GET request.
+   *
+   * @param url - The URL to request.
+   * @param options - Axios request configuration.
+   * @returns The response data.
+   */
+  get: <T = any, R = AxiosResponse<T>, D = any>(
+    url: string,
+    options?: AxiosRequestConfig<D>
+  ) => Promise<T>
+
+  /**
+   * Make a POST request.
+   *
+   * @param url - The URL to request.
+   * @param data - The data to send.
+   * @param options - Axios request configuration.
+   * @returns The response data.
+   */
+  post: <T = any, R = AxiosResponse<T>, D = any>(
+    url: string,
+    data?: D,
+    options?: AxiosRequestConfig<D>
+  ) => Promise<T>
+
+  /**
+   * Make a PUT request.
+   *
+   * @param url - The URL to request.
+   * @param data - The data to send.
+   * @param options - Axios request configuration.
+   * @returns The response data.
+   */
+  put: <T = any, R = AxiosResponse<T>, D = any>(
+    url: string,
+    data?: D,
+    options?: AxiosRequestConfig<D>
+  ) => Promise<T>
+
+  /**
+   * Make a PATCH request.
+   *
+   * @param url - The URL to request.
+   * @param data - The data to send.
+   * @param options - Axios request configuration.
+   * @returns The response data.
+   */
+  patch: <T = any, R = AxiosResponse<T>, D = any>(
+    url: string,
+    data?: D,
+    options?: AxiosRequestConfig<D>
+  ) => Promise<T>
+
+  /**
+   * Make a DELETE request.
+   *
+   * @param url - The URL to request.
+   * @param options - Axios request configuration.
+   * @returns The response data.
+   */
+  delete: <T = any, R = AxiosResponse<T>, D = any>(
+    url: string,
+    options?: AxiosRequestConfig<D>
+  ) => Promise<T>
+
+  /**
+   * Retrieves the access token.
+   *
+   * @returns The access token string.
+   */
+  getAccessToken: () => Promise<string>
+}

package/full-react-imperative/app/clients/contracts/ICommentClient.ts

@@ -0,0 +1,31 @@
+import { Comment, CommentInput } from '../../models/Comment'
+
+/**
+ * Comment Client contract
+ */
+export interface ICommentClient {
+  /**
+   * List comments for a given post.
+   *
+   * @param postId - The ID of the post to list comments for.
+   * @param limit - Optional limit of comments to retrieve (default: 10).
+   * @returns The list of comments.
+   */
+  list: (postId: number, limit?: number) => Promise<Comment[]>
+
+  /**
+   * Create a new comment for a given post.
+   *
+   * @param postId - The ID of the post to comment on.
+   * @param comment - The comment data.
+   * @returns The created comment.
+   */
+  create: (postId: number, comment: CommentInput) => Promise<Comment>
+
+  /**
+   * 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/clients/contracts/IPostClient.ts

@@ -0,0 +1,55 @@
+import { Post, PostInput } from '../../models/Post'
+
+/**
+ * Post Client contract
+ */
+export interface IPostClient {
+  /**
+   * List posts.
+   *
+   * @param limit - The 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 - The number of posts to retrieve (default: 10).
+   * @returns The list of posts.
+   */
+  listByAuthor: (id: number, limit?: number) => Promise<Post[]>
+
+  /**
+   * Find a post by ID.
+   *
+   * @param id - The ID of the post to find.
+   * @returns The found post.
+   */
+  find: (id: number) => Promise<Post>
+
+  /**
+   * Create a new post.
+   *
+   * @param post - The post data to create.
+   * @returns The created post.
+   */
+  create: (post: PostInput) => Promise<Post>
+
+  /**
+   * Update an existing post.
+   *
+   * @param id - The ID of the post to update.
+   * @param post - The updated post data.
+   * @returns The updated post.
+   */
+  update: (id: number, post: PostInput) => Promise<Post>
+
+  /**
+   * Delete a post.
+   *
+   * @param id - The ID of the post to delete.
+   */
+  delete: (id: number) => Promise<void>
+}