exnet-routing 1.2.0 → 1.2.2

package/dist/core/api/_type.d.ts

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { index } from "../index";
+type ApiService = typeof index;
+export type IHttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+export type IHttpMethodWithBody = "POST" | "PUT" | "DELETE";
+export type IHttpMethodWithoutBody = "GET";
+export declare const response: <R extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull>(data: R) => z.ZodUnion<[z.ZodObject<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}>, any>[k]; } : never, z.baseObjectInputType<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<{
+    data: R;
+    message: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodNever>;
+    success: z.ZodLiteral<true>;
+}>[k_1]; } : never>, z.ZodObject<{
+    data: z.ZodNever;
+    message: z.ZodString;
+    status: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodObject<{
+        message: z.ZodString;
+        info: z.ZodObject<{
+            status: z.ZodNumber;
+            code: z.ZodString;
+            messages: z.ZodArray<z.ZodObject<{
+                message: z.ZodString;
+                rule: z.ZodOptional<z.ZodString>;
+                field: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }, {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        }, {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        info: {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        };
+    }, {
+        message: string;
+        info: {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        };
+    }>;
+    success: z.ZodNever;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    data: never;
+    error: {
+        message: string;
+        info: {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        };
+    };
+    success: never;
+    status?: number | undefined;
+}, {
+    message: string;
+    data: never;
+    error: {
+        message: string;
+        info: {
+            status: number;
+            code: string;
+            messages: {
+                message: string;
+                rule?: string | undefined;
+                field?: string | undefined;
+            }[];
+        };
+    };
+    success: never;
+    status?: number | undefined;
+}>]>;
+export type IBaseRoute = {
+    url: string;
+    searchParams?: z.ZodObject<any>;
+    params?: z.ZodObject<any>;
+    response: ReturnType<typeof response>;
+};
+export type IRoute = IBaseRoute & ({
+    method: IHttpMethodWithBody;
+    body?: z.ZodObject<any>;
+} | {
+    method: IHttpMethodWithoutBody;
+    body?: never;
+});
+export type NestedRoute = {
+    [K: string]: NestedRoute | IRoute;
+};
+export declare const IApiType: <T extends NestedRoute>(api: T) => T;
+export type TransformApi<T extends NestedRoute> = {
+    [K in keyof T]: T[K] extends NestedRoute ? TransformApi<T[K]> : T[K]["body"] extends z.ZodObject<any> ? T[K]["searchParams"] extends z.ZodObject<any> ? T[K]["params"] extends z.ZodObject<any> ? (params: {
+        body: z.infer<T[K]["body"]>;
+        searchParams: z.infer<T[K]["searchParams"]>;
+        queryParams: z.infer<T[K]["params"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : (params: {
+        body: z.infer<T[K]["body"]>;
+        searchParams: z.infer<T[K]["searchParams"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : T[K]["params"] extends z.ZodObject<any> ? (params: {
+        body: z.infer<T[K]["body"]>;
+        queryParams: z.infer<T[K]["params"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : (params: {
+        body: z.infer<T[K]["body"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : T[K]["searchParams"] extends z.ZodObject<any> ? T[K]["params"] extends z.ZodObject<any> ? (params: {
+        searchParams: z.infer<T[K]["searchParams"]>;
+        queryParams: z.infer<T[K]["params"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : (params: {
+        searchParams: z.infer<T[K]["searchParams"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : T[K]["params"] extends z.ZodObject<any> ? (params: {
+        queryParams: z.infer<T[K]["params"]>;
+    }) => Promise<z.infer<T[K]["response"]>> : () => Promise<z.infer<T[K]["response"]>>;
+};
+export type ApiRouteResponse<Route extends (...args: any) => Promise<any>> = Awaited<ReturnType<Route>>["data"];
+export type IRouterApi = TransformApi<ApiService>;
+export type IRouteFunction = (...params: any[]) => Promise<IRoute["response"]>;
+export type IRouteGroup = {
+    [name: string]: IRouteFunction | IRouteGroup;
+};
+export {};

package/dist/core/api/_type.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IApiType = exports.response = void 0;
+const zod_1 = require("zod");
+const response = (data) => {
+    return zod_1.z
+        .object({
+        data,
+        message: zod_1.z.string().optional(),
+        status: zod_1.z.number().optional(),
+        error: zod_1.z.never().optional(),
+        success: zod_1.z.literal(true),
+    })
+        .or(zod_1.z.object({
+        data: zod_1.z.never(),
+        message: zod_1.z.string(),
+        status: zod_1.z.number().optional(),
+        error: zod_1.z.object({
+            message: zod_1.z.string(),
+            info: zod_1.z.object({
+                status: zod_1.z.number(),
+                code: zod_1.z.string(),
+                messages: zod_1.z.array(zod_1.z.object({
+                    message: zod_1.z.string(),
+                    rule: zod_1.z.string().optional(),
+                    field: zod_1.z.string().optional(),
+                })),
+            }),
+        }),
+        success: zod_1.z.never(),
+    }));
+};
+exports.response = response;
+const IApiType = (api) => api;
+exports.IApiType = IApiType;

package/dist/core/api/_untils.d.ts

@@ -0,0 +1,16 @@
+import { AxiosHeaders } from "axios";
+import { IRoute, IRouteGroup, IRouterApi } from "./_type";
+import { NestedRoute } from "./_type";
+export declare const apiUrlBuilder: (segment?: string, baseUrl?: string, host?: string) => string;
+export declare const apiFetch: {
+    setHostApi: (h: string) => void;
+    setBaseUrl: (b: string) => void;
+    setHeaders: (h: AxiosHeaders | undefined) => void;
+    fetch: (urlInput: string, method?: RequestInit["method"] | undefined, body?: any, searchParams?: any, queryParams?: {
+        [key: string]: string;
+    }) => Promise<any>;
+};
+export declare const isRoute: (value: NestedRoute | IRoute) => value is IRoute;
+export declare const isSubRoute: (value: NestedRoute | IRoute) => value is NestedRoute;
+export declare const parseApiRoute: <T extends NestedRoute | IRoute, K extends IRouteGroup>(key: string | undefined, subRoute: T, result: K, hostApi: string, basePath: string, headers?: AxiosHeaders) => K;
+export declare const parseApiRoutes: <T extends NestedRoute>(api: T, hostApi: string, basePath: string, headers?: AxiosHeaders) => IRouterApi;

package/dist/core/api/_untils.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseApiRoutes = exports.parseApiRoute = exports.isSubRoute = exports.isRoute = exports.apiFetch = exports.apiUrlBuilder = void 0;
+const path_1 = require("path");
+const axios_1 = __importDefault(require("axios"));
+let host;
+let baseUrl;
+let headers;
+const apiUrlBuilder = (segment = "", baseUrl = "", host = "") => {
+    const path = (0, path_1.join)(baseUrl, segment);
+    return host + path;
+};
+exports.apiUrlBuilder = apiUrlBuilder;
+exports.apiFetch = {
+    setHostApi: (h) => {
+        host = h;
+    },
+    setBaseUrl: (b) => {
+        baseUrl = b;
+    },
+    setHeaders: (h) => {
+        headers = h;
+    },
+    fetch: async (urlInput, method, body, searchParams, queryParams) => {
+        try {
+            let url = (0, exports.apiUrlBuilder)(urlInput, baseUrl, host);
+            if (queryParams) {
+                Object.entries(queryParams).forEach(([key, value]) => {
+                    if (value !== undefined && value !== null) {
+                        url = url.replace(`:${key}`, encodeURIComponent(String(value)));
+                    }
+                });
+            }
+            if (searchParams) {
+                const searchParamsString = typeof searchParams === "string"
+                    ? searchParams
+                    : Object.entries(searchParams)
+                        .filter(([_, value]) => value !== undefined && value !== null)
+                        .map(([key, value]) => {
+                        const encodedKey = encodeURIComponent(key);
+                        const encodedValue = Array.isArray(value) || typeof value === "object"
+                            ? encodeURIComponent(JSON.stringify(value))
+                            : encodeURIComponent(String(value !== null && value !== void 0 ? value : ""));
+                        return `${encodedKey}=${encodedValue}`;
+                    })
+                        .join("&");
+                url += (url.includes("?") ? "&" : "?") + searchParamsString;
+            }
+            const res = await (0, axios_1.default)({
+                headers: {
+                    "Content-Type": "application/json",
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+                    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+                    "Access-Control-Allow-Credentials": "true",
+                    "Access-Control-Allow-Private-Network": "true",
+                    Accept: "application/json",
+                    ...headers,
+                },
+                method,
+                url,
+                data: body,
+            });
+            return res.data;
+        }
+        catch (error) {
+            throw new Error(`Request failed: ${error}`);
+        }
+    },
+};
+const isRoute = (value) => {
+    return "method" in value;
+};
+exports.isRoute = isRoute;
+const isSubRoute = (value) => {
+    return !(0, exports.isRoute)(value);
+};
+exports.isSubRoute = isSubRoute;
+const createRouteFunction = (route, apiFetch) => {
+    const createFetchFunction = (paramTypes) => {
+        return async (...args) => {
+            const params = paramTypes.reduce((acc, type) => {
+                acc[type] = args[0][type] || null;
+                return acc;
+            }, {});
+            return await apiFetch.fetch(route.url, route.method, params.body, params.searchParams, params.queryParams);
+        };
+    };
+    if (route.body) {
+        if (route.searchParams) {
+            return route.params
+                ? createFetchFunction(["body", "searchParams", "queryParams"])
+                : createFetchFunction(["body", "searchParams"]);
+        }
+        return route.params ? createFetchFunction(["body", "queryParams"]) : createFetchFunction(["body"]);
+    }
+    if (route.searchParams) {
+        return route.params ? createFetchFunction(["searchParams", "queryParams"]) : createFetchFunction(["searchParams"]);
+    }
+    return route.params ? createFetchFunction(["queryParams"]) : createFetchFunction([]);
+};
+const parseApiRoute = (key, subRoute, result, hostApi, basePath, headers) => {
+    var _a;
+    exports.apiFetch.setHostApi(hostApi);
+    exports.apiFetch.setBaseUrl(basePath);
+    exports.apiFetch.setHeaders(headers);
+    if ((0, exports.isRoute)(subRoute) && key) {
+        ;
+        result = createRouteFunction(subRoute, exports.apiFetch);
+    }
+    else if ((0, exports.isSubRoute)(subRoute)) {
+        for (const [key, value] of Object.entries(subRoute)) {
+            ;
+            result[key] = (0, exports.parseApiRoute)(key, value, ((_a = result[key]) !== null && _a !== void 0 ? _a : {}), hostApi, basePath, headers);
+        }
+    }
+    return result;
+};
+exports.parseApiRoute = parseApiRoute;
+const parseApiRoutes = (api, hostApi, basePath, headers) => {
+    const result = {};
+    const response = (0, exports.parseApiRoute)(undefined, api, result, hostApi, basePath, headers);
+    return response;
+};
+exports.parseApiRoutes = parseApiRoutes;

package/dist/core/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.index = void 0;
 const public_1 = require("./../routes/public");
 const user_1 = require("./../routes/user");
-const _type_1 = require("./_type");
+const _type_1 = require("./api/_type");
 const driver_1 = require("./../routes/driver");
 const admin_1 = require("./../routes/admin");
 const ops_1 = require("./../routes/ops");

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { index } from "./core/index";
-import { TransformApi } from "./core/_type";
+import { TransformApi } from "./core/api/_type";
 import { AxiosHeaderValue } from "axios";
 type RecordHeaders = {
     [x: string]: AxiosHeaderValue | undefined;

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APIRouter = void 0;
-const _untils_1 = require("./core/_untils");
+const _untils_1 = require("./core/api/_untils");
 const index_1 = require("./core/index");
 const axios_1 = require("axios");
 class APIRouter {

package/dist/routes/admin.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.adminRoutes = void 0;
 const zod_1 = require("zod");
-const _type_1 = require("../core/_type");
+const _type_1 = require("../core/api/_type");
 const models_1 = require("./../models");
 const _user_1 = require("./../models/_user");
 const baseurl = "/admin";

package/dist/routes/driver.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.driverRoutes = void 0;
-const _type_1 = require("../core/_type");
+const _type_1 = require("../core/api/_type");
 // const baseurl = "/user"
 exports.driverRoutes = (0, _type_1.IApiType)({});

package/dist/routes/ops.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.opsRoutes = void 0;
 const zod_1 = require("zod");
-const _type_1 = require("../core/_type");
+const _type_1 = require("../core/api/_type");
 const models_1 = require("./../models");
 const baseurl = "/ops";
 const dashboardRoutes = (0, _type_1.IApiType)({

package/dist/routes/public.d.ts

@@ -642,6 +642,16 @@ export declare const publicRoutes: {
                             bipTelepage: string;
                         } | undefined;
                     }>;
+                    ws: z.ZodObject<{
+                        user: z.ZodString;
+                        roles: z.ZodArray<z.ZodString, "many">;
+                    }, "strip", z.ZodTypeAny, {
+                        roles: string[];
+                        user: string;
+                    }, {
+                        roles: string[];
+                        user: string;
+                    }>;
                 }, "strip", z.ZodTypeAny, {
                     token: {
                         type: "Bearer";
@@ -801,6 +811,10 @@ export declare const publicRoutes: {
                         lastUsedAt?: string | undefined;
                         expiresAt?: string | undefined;
                     };
+                    ws: {
+                        roles: string[];
+                        user: string;
+                    };
                 }, {
                     token: {
                         type: "Bearer";
@@ -960,6 +974,10 @@ export declare const publicRoutes: {
                         lastUsedAt?: string | undefined;
                         expiresAt?: string | undefined;
                     };
+                    ws: {
+                        roles: string[];
+                        user: string;
+                    };
                 }>;
                 message: z.ZodOptional<z.ZodString>;
                 status: z.ZodOptional<z.ZodNumber>;
@@ -1125,6 +1143,10 @@ export declare const publicRoutes: {
                         lastUsedAt?: string | undefined;
                         expiresAt?: string | undefined;
                     };
+                    ws: {
+                        roles: string[];
+                        user: string;
+                    };
                 };
                 success: true;
                 status?: number | undefined;
@@ -1290,6 +1312,10 @@ export declare const publicRoutes: {
                         lastUsedAt?: string | undefined;
                         expiresAt?: string | undefined;
                     };
+                    ws: {
+                        roles: string[];
+                        user: string;
+                    };
                 };
                 success: true;
                 status?: number | undefined;

package/dist/routes/public.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.publicRoutes = void 0;
 const zod_1 = require("zod");
-const _type_1 = require("../core/_type");
+const _type_1 = require("../core/api/_type");
 const models_1 = require("./../models");
 const baseurl = "";
 exports.publicRoutes = (0, _type_1.IApiType)({
@@ -15,6 +15,10 @@ exports.publicRoutes = (0, _type_1.IApiType)({
                 token: models_1.TokenSchema,
                 refreshToken: models_1.TokenSchema,
                 user: models_1.UserSchema,
+                ws: zod_1.z.object({
+                    user: zod_1.z.string(),
+                    roles: zod_1.z.array(zod_1.z.string()),
+                }),
             })),
         },
         forgotPassword: {

package/dist/routes/user.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.userRoutes = void 0;
 const zod_1 = require("zod");
-const _type_1 = require("../core/_type");
+const _type_1 = require("../core/api/_type");
 const models_1 = require("./../models");
 const _untils_1 = require("./../models/_untils");
 const baseurl = "/user";
@@ -111,7 +111,7 @@ const shippingRoutes = (0, _type_1.IApiType)({
     },
     create: {
         method: "POST",
-        url: `${baseurl}/shipping/:userInterface/create`,
+        url: `${baseurl}/shipping/:userInterface/create/:typeExpedition`,
         params: zod_1.z.object({
             userInterface: zod_1.z.enum(["paris", "medical", "service"]),
             typeExpedition: zod_1.z.enum(["import", "export", "course"]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exnet-routing",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [