snap-on-openapi 1.0.1

package/dist/services/ValidationUtils/ValidationUtils.d.ts

@@ -0,0 +1,56 @@
+import 'zod-openapi/extend';
+import { ZodObject, ZodRawShape, ZodType } from 'zod';
+export declare class ValidationUtils {
+    readonly strings: {
+        datetime: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Date, string>;
+        number: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, number, string>;
+        boolean: import("zod").ZodEffects<import("zod").ZodEnum<["true", "false"]>, boolean, "true" | "false">;
+    };
+    describeShape<TShape extends ZodRawShape>(val: ZodObject<TShape>, descriptions: Record<keyof TShape, string>): ZodObject<TShape>;
+    paginatedQuery<X extends ZodRawShape>(filter: X): ZodObject<import("zod").objectUtil.extendShape<{
+        page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, X>, "strip", import("zod").ZodTypeAny, import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<import("zod").objectUtil.extendShape<{
+        page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, X>>, any> extends infer T ? { [k in keyof T]: import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<import("zod").objectUtil.extendShape<{
+        page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, X>>, any>[k]; } : never, import("zod").baseObjectInputType<import("zod").objectUtil.extendShape<{
+        page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, X>> extends infer T_1 ? { [k_1 in keyof T_1]: import("zod").baseObjectInputType<import("zod").objectUtil.extendShape<{
+        page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, X>>[k_1]; } : never>;
+    paginatedResponse<T extends ZodType>(arr: T): ZodObject<{
+        items: import("zod").ZodArray<T, "many">;
+        info: ZodObject<{
+            count: import("zod").ZodNumber;
+            page: import("zod").ZodNumber;
+            pageSize: import("zod").ZodNumber;
+        }, "strip", import("zod").ZodTypeAny, {
+            page: number;
+            pageSize: number;
+            count: number;
+        }, {
+            page: number;
+            pageSize: number;
+            count: number;
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        info: {
+            page: number;
+            pageSize: number;
+            count: number;
+        };
+        items: T["_output"][];
+    }, {
+        info: {
+            page: number;
+            pageSize: number;
+            count: number;
+        };
+        items: T["_input"][];
+    }>;
+}

package/dist/services/ValidationUtils/ValidationUtils.js

@@ -0,0 +1,38 @@
+import 'zod-openapi/extend';
+import { array, number, object } from 'zod';
+import { stringDateTransformer } from './transformers/stringDateTransformer.js';
+import { stringNumberTransformer } from './transformers/stringNumberTransfromer.js';
+import { stringBooleanTransformer } from './transformers/stringBooleanTransformer.js';
+export class ValidationUtils {
+    strings = {
+        datetime: stringDateTransformer,
+        number: stringNumberTransformer,
+        boolean: stringBooleanTransformer,
+    };
+    describeShape(val, descriptions) {
+        const newShape = {};
+        for (const entry of Object.entries(val.shape)) {
+            newShape[entry[0]] = entry[1].openapi({ description: descriptions[entry[0]] });
+        }
+        return object(newShape);
+    }
+    paginatedQuery(filter) {
+        return object({
+            page: number().min(1).optional().default(1).openapi({ description: 'Page number' }),
+            pageSize: number().min(1).optional().openapi({
+                description: 'Number of items to display in the page.',
+            }),
+        }).extend(filter).openapi({ description: 'Pagination parameters' });
+    }
+    paginatedResponse(arr) {
+        return object({
+            items: array(arr).openapi({ description: 'Page or items' }),
+            info: object({
+                count: number().openapi({ description: 'Total number of items' }),
+                page: number().openapi({ description: 'Current page' }),
+                pageSize: number().openapi({ description: 'Number of itemss per page' }),
+            })
+                .openapi({ description: 'Pagination details' }),
+        });
+    }
+}

package/dist/services/ValidationUtils/transformers/stringBooleanTransformer.d.ts

@@ -0,0 +1,3 @@
+import 'zod-openapi/extend';
+import z from 'zod';
+export declare const stringBooleanTransformer: z.ZodEffects<z.ZodEnum<["true", "false"]>, boolean, "true" | "false">;

package/dist/services/ValidationUtils/transformers/stringBooleanTransformer.js

@@ -0,0 +1,5 @@
+import 'zod-openapi/extend';
+import z from 'zod';
+export const stringBooleanTransformer = z.enum(['true', 'false']).transform((val) => {
+    return val === 'true';
+}).openapi({ type: 'boolean' });

package/dist/services/ValidationUtils/transformers/stringDateTransformer.d.ts

@@ -0,0 +1,3 @@
+import 'zod-openapi/extend';
+import z from 'zod';
+export declare const stringDateTransformer: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Date, string>;

package/dist/services/ValidationUtils/transformers/stringDateTransformer.js

@@ -0,0 +1,16 @@
+import 'zod-openapi/extend';
+import z from 'zod';
+export const stringDateTransformer = z.string().refine((input) => {
+    try {
+        const output = new Date(Date.parse(input));
+        const outputStr = output.toISOString().replace('T', ' ');
+        const inputStr = input.replace('T', ' ');
+        return inputStr === outputStr;
+    }
+    catch (e) {
+        return false;
+    }
+}, 'Not a valid date string')
+    .transform((x) => {
+    return new Date(Date.parse(x));
+}).openapi({ type: 'string', format: 'date-time' });

package/dist/services/ValidationUtils/transformers/stringNumberTransfromer.d.ts

@@ -0,0 +1,3 @@
+import 'zod-openapi/extend';
+import z from 'zod';
+export declare const stringNumberTransformer: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, number, string>;

package/dist/services/ValidationUtils/transformers/stringNumberTransfromer.js

@@ -0,0 +1,24 @@
+import 'zod-openapi/extend';
+import z from 'zod';
+export const stringNumberTransformer = z.string().refine((input) => {
+    try {
+        if (input === '') {
+            return false;
+        }
+        const number = Number(input);
+        if (isNaN(number)) {
+            return false;
+        }
+        if (!isFinite(number)) {
+            return false;
+        }
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}, 'Not a valid number string')
+    .transform((x) => {
+    return Number(x);
+}).openapi({ type: 'number' });
+;

package/dist/services/ValidationUtils/types/PaginatedResponse.d.ts

@@ -0,0 +1,8 @@
+export interface PaginatedResponse<T> {
+    items: T[];
+    info: {
+        count: number;
+        page: number;
+        pageSize: number;
+    };
+}

package/dist/services/ValidationUtils/types/PaginatedResponse.js

@@ -0,0 +1 @@
+export {};

package/dist/types/AnyRoute.d.ts

@@ -0,0 +1,3 @@
+import { ZodObject, ZodRawShape, ZodFirstPartySchemaTypes } from 'zod';
+import { Route } from './Route.js';
+export type AnyRoute<TRouteType extends string> = Route<TRouteType, any, ZodFirstPartySchemaTypes, ZodObject<ZodRawShape> | undefined, ZodObject<ZodRawShape> | undefined, ZodObject<ZodRawShape> | undefined>;

package/dist/types/AnyRoute.js

@@ -0,0 +1 @@
+export {};

package/dist/types/InitialBuilder.d.ts

@@ -0,0 +1,9 @@
+import { ErrorCode } from '../enums/ErrorCode.js';
+import { SampleRouteType } from '../enums/SampleRouteType.js';
+import { ConfigBuilder } from '../services/ConfigBuilder/ConfigBuilder.js';
+import { DefaultConfig } from '../services/ConfigBuilder/types/DefaultConfig.js';
+import { DefaultErrorMap } from '../services/ConfigBuilder/types/DefaultErrorMap.js';
+import { DefaultRouteContextMap } from '../services/ConfigBuilder/types/DefaultRouteContextMap.js';
+import { DefaultRouteMap } from '../services/ConfigBuilder/types/DefaultRouteMap.js';
+import { DefaultRouteParamsMap } from '../services/ConfigBuilder/types/DefaultRouteParamsMap.js';
+export type InitialBuilder = Pick<ConfigBuilder<SampleRouteType, ErrorCode, DefaultErrorMap, DefaultRouteParamsMap, DefaultRouteContextMap, DefaultRouteMap, DefaultConfig>, 'customizeErrors' | 'create' | 'defineGlobalConfig' | 'customizeRoutes'>;

package/dist/types/InitialBuilder.js

@@ -0,0 +1 @@
+export {};

package/dist/types/NonEmptyArray.d.ts

@@ -0,0 +1 @@
+export type NonEmptyArray<T> = [T, ...T[]];

package/dist/types/NonEmptyArray.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Route.d.ts

@@ -0,0 +1,22 @@
+import { z, ZodFirstPartySchemaTypes, ZodObject, ZodRawShape } from 'zod';
+import { Method } from '../enums/Methods.js';
+import { RoutePath } from './RoutePath.js';
+export interface Route<TType extends string, TContext extends object, TResponseValidator extends ZodFirstPartySchemaTypes, TPathValidator extends ZodObject<ZodRawShape> | undefined, TQueryValidator extends ZodObject<ZodRawShape> | undefined, TBodyValidator extends ZodObject<ZodRawShape> | undefined, TMethod extends Method = Method> {
+    type: TType;
+    method: TMethod;
+    path: RoutePath;
+    description: string;
+    validators: {
+        query?: TQueryValidator;
+        path?: TPathValidator;
+        body?: TMethod extends 'GET' ? never : TBodyValidator;
+        response: TResponseValidator;
+    };
+    handler: (context: {
+        params: {
+            body: TBodyValidator extends ZodObject<ZodRawShape> ? z.infer<TBodyValidator> : object;
+            query: TQueryValidator extends ZodObject<ZodRawShape> ? z.infer<TQueryValidator> : object;
+            path: TPathValidator extends ZodObject<ZodRawShape> ? z.infer<TPathValidator> : object;
+        };
+    } & TContext) => Promise<z.infer<TResponseValidator>>;
+}

package/dist/types/Route.js

@@ -0,0 +1 @@
+export {};

package/dist/types/RouteMap.d.ts

@@ -0,0 +1,3 @@
+import { AnyRoute } from './AnyRoute.js';
+import { RoutePath } from './RoutePath.js';
+export type RouteMap<TRouteType extends string> = Record<RoutePath, AnyRoute<TRouteType>[]>;

package/dist/types/RouteMap.js

@@ -0,0 +1 @@
+export {};

package/dist/types/RoutePath.d.ts

@@ -0,0 +1 @@
+export type RoutePath = `/${string}` | '/';

package/dist/types/RoutePath.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Wrappers.d.ts

@@ -0,0 +1,7 @@
+import { ExpressWrapper } from '../services/ExpressWrapper/ExpressWrapper.js';
+import { TanstackStartWrapper } from '../services/TanstackStartWrapper/TanstackStartWrapper.js';
+import { AnyConfig } from './config/AnyConfig.js';
+export interface Wrappers<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
+    tanstackStart: TanstackStartWrapper<TRouteTypes, TErrorCodes, TConfig>;
+    express: ExpressWrapper<TRouteTypes, TErrorCodes, TConfig>;
+}

package/dist/types/Wrappers.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/AnyConfig.d.ts

@@ -0,0 +1,4 @@
+import { ErrorConfigMap } from './ErrorConfigMap.js';
+import { Config } from './Config.js';
+import { RouteConfigMap } from './RouteConfigMap.js';
+export type AnyConfig<TRouteTypes extends string, TErrorCodes extends string> = Config<TRouteTypes, TErrorCodes, ErrorConfigMap<TErrorCodes>, any, any, RouteConfigMap<TRouteTypes, TErrorCodes, any, any>>;

package/dist/types/config/AnyConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/AnyRouteConfigMap.d.ts

@@ -0,0 +1,4 @@
+import { RouteConfig } from './RouteConfig.js';
+export type AnyRouteConfigMap<TRouteTypes extends string, TErrorCodes extends string> = {
+    [key in TRouteTypes]: RouteConfig<key, TErrorCodes, any, any>;
+};

package/dist/types/config/AnyRouteConfigMap.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/Config.d.ts

@@ -0,0 +1,19 @@
+import { LogLevel } from '../../services/Logger/types/LogLevel.js';
+import { RoutePath } from '../RoutePath.js';
+import { ErrorConfigMap } from './ErrorConfigMap.js';
+import { ErrorResponse } from './ErrorResponse.js';
+import { RouteConfigMap } from './RouteConfigMap.js';
+import { RouteContextMap } from './RouteContextMap.js';
+import { RouteExtraPropsMap } from './RouteExtraPropsMap.js';
+import { Server } from './Server.js';
+export type Config<TRouteTypes extends string, TErrorCodes extends string, TErrorConfigMap extends ErrorConfigMap<TErrorCodes>, TRouteParamMap extends RouteExtraPropsMap<TRouteTypes>, TRouteContextMap extends RouteContextMap<TRouteTypes, TRouteParamMap>, TRouteConfigMap extends RouteConfigMap<TRouteTypes, TErrorCodes, TRouteParamMap, TRouteContextMap>> = {
+    basePath: RoutePath;
+    routes: TRouteConfigMap;
+    errors: TErrorConfigMap;
+    defaultError: ErrorResponse<TErrorCodes, TErrorConfigMap>;
+    skipDescriptionsCheck?: boolean;
+    apiName?: string;
+    servers?: Server[];
+    logLevel?: LogLevel;
+    handleError?: (e: unknown) => ErrorResponse<TErrorCodes, TErrorConfigMap>;
+};

package/dist/types/config/Config.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/ContextParams.d.ts

@@ -0,0 +1,12 @@
+import { ZodObject, ZodRawShape } from 'zod';
+import { AnyRoute } from '../AnyRoute.js';
+import { RouteExtraProps } from './RouteExtraProps.js';
+export type ContextParams<TRouteType extends string, TExtraProps extends ZodObject<ZodRawShape> | undefined> = {
+    route: AnyRoute<TRouteType> & RouteExtraProps<TExtraProps>;
+    request: Request;
+    params: {
+        body: unknown;
+        query: unknown;
+        path: unknown;
+    };
+};

package/dist/types/config/ContextParams.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/ErrorConfig.d.ts

@@ -0,0 +1,6 @@
+import { ZodObject, ZodRawShape } from 'zod';
+export type ErrorConfig<T extends ZodObject<ZodRawShape>> = {
+    status: `${1 | 2 | 3 | 4 | 5}${string}`;
+    description: string;
+    responseValidator: T;
+};

package/dist/types/config/ErrorConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/ErrorConfigMap.d.ts

@@ -0,0 +1,5 @@
+import { ZodObject, ZodRawShape } from 'zod';
+import { ErrorConfig } from './ErrorConfig.js';
+export type ErrorConfigMap<TEnum extends string> = {
+    [key in TEnum]: ErrorConfig<ZodObject<ZodRawShape>>;
+};

package/dist/types/config/ErrorConfigMap.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/ErrorResponse.d.ts

@@ -0,0 +1,8 @@
+import { TypeOf } from 'zod';
+import { ErrorConfigMap } from './ErrorConfigMap.js';
+export type ErrorResponse<TErrorCodes extends string, TErrorConfigMap extends ErrorConfigMap<TErrorCodes>> = {
+    [K in TErrorCodes]: {
+        code: K;
+        body: TypeOf<TErrorConfigMap[K]['responseValidator']>;
+    };
+}[TErrorCodes];

package/dist/types/config/ErrorResponse.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/ISpecificationExtension.d.ts

@@ -0,0 +1,6 @@
+type IExtensionName = `x-${string}`;
+type IExtensionType = any;
+export type ISpecificationExtension = {
+    [extensionName: IExtensionName]: IExtensionType;
+};
+export {};

package/dist/types/config/ISpecificationExtension.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/Info.d.ts

@@ -0,0 +1,7 @@
+import { ISpecificationExtension } from './ISpecificationExtension.js';
+export interface Info extends ISpecificationExtension {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    version: string;
+}

package/dist/types/config/Info.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/OmitMappedField.d.ts

@@ -0,0 +1,3 @@
+export type OmitMappedField<TMap extends Record<string, any>, T extends string> = {
+    [key in keyof TMap]: Omit<TMap[key], T>;
+};

package/dist/types/config/OmitMappedField.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/RouteConfig.d.ts

@@ -0,0 +1,10 @@
+import { ZodObject, ZodRawShape } from 'zod';
+import { ContextParams } from './ContextParams.js';
+export type RouteConfig<TRouteType extends string, TErrorCodes extends string, TExtraProps extends ZodObject<ZodRawShape> | undefined = ZodObject<ZodRawShape> | undefined, TContext extends object | undefined = object | undefined> = {
+    authorization: boolean;
+    extraProps: TExtraProps;
+    contextFactory: (params: ContextParams<TRouteType, TExtraProps>) => Promise<TContext>;
+    errors?: {
+        [key in TErrorCodes]?: true;
+    };
+};

package/dist/types/config/RouteConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/RouteConfigMap.d.ts

@@ -0,0 +1,7 @@
+import { ZodObject, ZodRawShape } from 'zod';
+import { RouteConfig } from './RouteConfig.js';
+import { RouteExtraPropsMap } from './RouteExtraPropsMap.js';
+import { RouteContextMap } from './RouteContextMap.js';
+export type RouteConfigMap<TRouteTypes extends string, TErrorCodes extends string, TParamsMap extends RouteExtraPropsMap<TRouteTypes, ZodObject<ZodRawShape> | undefined> | undefined = undefined, TContextMap extends RouteContextMap<TRouteTypes, TParamsMap> | undefined = undefined> = {
+    [key in TRouteTypes]: RouteConfig<key, TErrorCodes, TParamsMap extends undefined ? undefined : Exclude<TParamsMap, undefined>[key], TContextMap extends undefined ? undefined : Awaited<ReturnType<Exclude<TContextMap, undefined>[key]>>>;
+};

package/dist/types/config/RouteConfigMap.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/RouteContextMap.d.ts

@@ -0,0 +1,6 @@
+import { ZodObject, ZodRawShape } from 'zod';
+import { RouteExtraPropsMap } from './RouteExtraPropsMap.js';
+import { ContextParams } from './ContextParams.js';
+export type RouteContextMap<TCode extends string, TParamsMap extends RouteExtraPropsMap<TCode, ZodObject<ZodRawShape> | undefined> | undefined> = {
+    [key in TCode]: (params: ContextParams<key, TParamsMap extends undefined ? undefined : Exclude<TParamsMap, undefined>[key]>) => Promise<object>;
+};

package/dist/types/config/RouteContextMap.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/RouteExtraProps.d.ts

@@ -0,0 +1,2 @@
+import { ZodObject, ZodRawShape, TypeOf } from 'zod';
+export type RouteExtraProps<TValidator extends ZodObject<ZodRawShape> | undefined, TSwapVal = object> = TValidator extends undefined ? TSwapVal : TypeOf<Exclude<TValidator, undefined>>;

package/dist/types/config/RouteExtraProps.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/RouteExtraPropsMap.d.ts

@@ -0,0 +1,4 @@
+import { ZodObject, ZodRawShape } from 'zod';
+export type RouteExtraPropsMap<TCode extends string, TVal extends ZodObject<ZodRawShape> | undefined = ZodObject<ZodRawShape> | undefined> = {
+    [key in TCode]: TVal;
+};

package/dist/types/config/RouteExtraPropsMap.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/Server.d.ts

@@ -0,0 +1,5 @@
+import { ISpecificationExtension } from './ISpecificationExtension.js';
+export interface Server extends ISpecificationExtension {
+    description: string;
+    url: string;
+}

package/dist/types/config/Server.js

@@ -0,0 +1 @@
+export {};

package/dist/types/errors/ApiError.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class ApiError<TCode extends string> extends Error {
+    private code;
+    constructor(code: TCode);
+    getCode(): TCode;
+}

package/dist/types/errors/ApiError.js

@@ -0,0 +1,10 @@
+export class ApiError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+    getCode() {
+        return this.code;
+    }
+}

package/dist/types/errors/BuiltInError.d.ts

@@ -0,0 +1,4 @@
+import { ErrorCode } from '../../enums/ErrorCode.js';
+import { ApiError } from './ApiError.js';
+export declare class BuiltInError extends ApiError<ErrorCode> {
+}

package/dist/types/errors/BuiltInError.js

@@ -0,0 +1,3 @@
+import { ApiError } from './ApiError.js';
+export class BuiltInError extends ApiError {
+}

package/dist/types/errors/FieldError.d.ts

@@ -0,0 +1,33 @@
+import 'zod-openapi/extend';
+import { z } from 'zod';
+export declare const fieldErrorValidator: z.ZodObject<{
+    field: z.ZodString;
+    message: z.ZodString;
+} & {
+    fieldErrors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        field: string;
+    }, {
+        message: string;
+        field: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    field: string;
+    fieldErrors?: {
+        message: string;
+        field: string;
+    }[] | undefined;
+}, {
+    message: string;
+    field: string;
+    fieldErrors?: {
+        message: string;
+        field: string;
+    }[] | undefined;
+}>;
+export type FieldErrorValidator = typeof fieldErrorValidator;
+export type FieldError = z.TypeOf<FieldErrorValidator>;

package/dist/types/errors/FieldError.js

@@ -0,0 +1,9 @@
+import 'zod-openapi/extend';
+import { z } from 'zod';
+const baseFieldErrorValidator = z.object({
+    field: z.string().openapi({ description: 'Name of the field' }),
+    message: z.string().openapi({ description: 'Error message' }),
+}).openapi({ description: 'Field error' });
+export const fieldErrorValidator = baseFieldErrorValidator.extend({
+    fieldErrors: z.array(baseFieldErrorValidator).optional(),
+});

package/dist/types/errors/ValidationError.d.ts

@@ -0,0 +1,10 @@
+import { ZodError } from 'zod';
+import { ValidationLocation } from '../../enums/ValidationLocations.js';
+import { BuiltInError } from './BuiltInError.js';
+export declare class ValidationError extends BuiltInError {
+    private error;
+    private location;
+    constructor(error: ZodError<unknown>, location: ValidationLocation);
+    getZodError(): ZodError<unknown>;
+    getLocation(): ValidationLocation;
+}

package/dist/types/errors/ValidationError.js

@@ -0,0 +1,17 @@
+import { ErrorCode } from '../../enums/ErrorCode.js';
+import { BuiltInError } from './BuiltInError.js';
+export class ValidationError extends BuiltInError {
+    error;
+    location;
+    constructor(error, location) {
+        super(ErrorCode.ValidationFailed);
+        this.error = error;
+        this.location = location;
+    }
+    getZodError() {
+        return this.error;
+    }
+    getLocation() {
+        return this.location;
+    }
+}

package/dist/types/errors/responses/NotFoundErrorResponse.d.ts

@@ -0,0 +1,12 @@
+import 'zod-openapi/extend';
+import { z } from 'zod';
+import { ErrorCode } from '../../../enums/ErrorCode.js';
+export declare const notFoundErrorResponseValidator: z.ZodObject<{
+    error: z.ZodLiteral<ErrorCode.NotFound>;
+}, "strip", z.ZodTypeAny, {
+    error: ErrorCode.NotFound;
+}, {
+    error: ErrorCode.NotFound;
+}>;
+export type NotFoundErrorResponseValidator = typeof notFoundErrorResponseValidator;
+export type NotFoundErrorResponse = z.TypeOf<NotFoundErrorResponseValidator>;

package/dist/types/errors/responses/NotFoundErrorResponse.js

@@ -0,0 +1,6 @@
+import 'zod-openapi/extend';
+import { z } from 'zod';
+import { ErrorCode } from '../../../enums/ErrorCode.js';
+export const notFoundErrorResponseValidator = z.object({
+    error: z.literal(ErrorCode.NotFound).openapi({ description: 'Code to handle on the frontend' }),
+}).openapi({ description: 'Error response' });

package/dist/types/errors/responses/UnknownErrorResponse.d.ts

@@ -0,0 +1,12 @@
+import 'zod-openapi/extend';
+import { z } from 'zod';
+import { ErrorCode } from '../../../enums/ErrorCode.js';
+export declare const unknownErrorResponseValidator: z.ZodObject<{
+    error: z.ZodLiteral<ErrorCode.UnknownError>;
+}, "strip", z.ZodTypeAny, {
+    error: ErrorCode.UnknownError;
+}, {
+    error: ErrorCode.UnknownError;
+}>;
+export type UnknownErrorResponseValidator = typeof unknownErrorResponseValidator;
+export type UnknownErrorResponse = z.TypeOf<UnknownErrorResponseValidator>;

package/dist/types/errors/responses/UnknownErrorResponse.js

@@ -0,0 +1,6 @@
+import 'zod-openapi/extend';
+import { z } from 'zod';
+import { ErrorCode } from '../../../enums/ErrorCode.js';
+export const unknownErrorResponseValidator = z.object({
+    error: z.literal(ErrorCode.UnknownError).openapi({ description: 'Code to handle on the frontend' }),
+}).openapi({ description: 'Error response' });