commit 2c8bdef4eca30225b17cfe04164f14d8f6253394 · gmstn.systems/shard

+14 -10

src/lib/types/http/responses.ts

···

       24
       24
        
           error: z.optional(httpResponseErrorInfoSchema),

     

       25
       25
        
       });

     

       26
       26
        
       

     

       27
       27
       -
       export const httpSuccessResponseSchema = httpResponseBaseSchema.safeExtend({

     

       28
       28
       -
           status: z.literal(HttpResponseStatusType.SUCCESS),

     

       29
       29
       -
           data: httpResponseDataSchema,

     

       30
       30
       -
           error: z.undefined(),

     

       31
       31
       -
       });

     

       27
       27
       +
       export const httpSuccessResponseSchema = httpResponseBaseSchema

     

       28
       28
       +
           .safeExtend({

     

       29
       29
       +
               status: z.literal(HttpResponseStatusType.SUCCESS),

     

       30
       30
       +
               data: httpResponseDataSchema,

     

       31
       31
       +
               error: z.undefined(),

     

       32
       32
       +
           })

     

       33
       33
       +
           .omit({ error: true });

     

       32
       34
        
       export type HttpSuccessResponse = z.infer<typeof httpSuccessResponseSchema>;

     

       33
       35
        
       

     

       34
       34
       -
       export const httpErrorResponseSchema = httpResponseBaseSchema.safeExtend({

     

       35
       35
       -
           status: z.literal(HttpResponseStatusType.ERROR),

     

       36
       36
       -
           error: httpResponseErrorInfoSchema,

     

       37
       37
       -
           data: z.undefined(),

     

       38
       38
       -
       });

     

       36
       36
       +
       export const httpErrorResponseSchema = httpResponseBaseSchema

     

       37
       37
       +
           .safeExtend({

     

       38
       38
       +
               status: z.literal(HttpResponseStatusType.ERROR),

     

       39
       39
       +
               error: httpResponseErrorInfoSchema,

     

       40
       40
       +
               data: z.undefined(),

     

       41
       41
       +
           })

     

       42
       42
       +
           .omit({ data: true });

     

       39
       43
        
       export type HttpErrorResponse = z.infer<typeof httpErrorResponseSchema>;

+10 -4

src/lib/utils/http/responses.ts

···

       1
       1
       +
       import type { HttpResponseErrorInfo } from "@/lib/types/http/errors";

     

       1
       2
        
       import type {

     

       2
       3
        
           HttpErrorResponse,

     

       3
       4
        
           HttpResponseData,

     

       5
       5
       +
           HttpSuccessResponse,

     

       4
       6
        
       } from "@/lib/types/http/responses";

     

       5
       7
        
       import { HttpResponseStatusType } from "@/lib/types/http/responses";

     

       6
       8
        
       

     

       7
       9
        
       export const newSuccessResponse = (data: HttpResponseData) => {

     

       8
       8
       -
           const response = {

     

       10
       10
       +
           const body: HttpSuccessResponse = {

     

       9
       11
        
               status: HttpResponseStatusType.SUCCESS,

     

       10
       12
        
               data,

     

       11
       13
        
           };

     

       12
       12
       -
           return new Response(JSON.stringify(response), {

     

       14
       14
       +
           return new Response(JSON.stringify(body), {

     

       13
       15
        
               status: 200,

     

       14
       16
        
               headers: {

     

       15
       17
        
                   "Content-Type": "application/json",

     
···

       19
       21
        
       

     

       20
       22
        
       export const newErrorResponse = (

     

       21
       23
        
           httpCode: number,

     

       22
       22
       -
           errorObj: HttpErrorResponse,

     

       24
       24
       +
           errorObj: HttpResponseErrorInfo,

     

       23
       25
        
       ) => {

     

       24
       24
       -
           return new Response(JSON.stringify(errorObj), {

     

       26
       26
       +
           const body: HttpErrorResponse = {

     

       27
       27
       +
               status: HttpResponseStatusType.ERROR,

     

       28
       28
       +
               error: errorObj,

     

       29
       29
       +
           };

     

       30
       30
       +
           return new Response(JSON.stringify(body), {

     

       25
       31
        
               status: httpCode,

     

       26
       32
        
               headers: {

     

       27
       33
        
                   "Content-Type": "application/json",