exnet-routing 0.0.0

package/.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Release
+on:
+  pull_request:
+    branches:
+      - rec
+    types: [closed]
+
+jobs:
+  release:
+    name: Release
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npx semantic-release 

package/.prettierignore

@@ -0,0 +1,2 @@
+.next
+node_modules

package/.releaserc.json

@@ -0,0 +1,13 @@
+{
+  "branches": ["rec"],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    "@semantic-release/npm",
+    ["@semantic-release/git", {
+      "assets": ["package.json", "CHANGELOG.md"],
+      "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+    }]
+  ]
+} 

package/README.md

@@ -0,0 +1 @@
+# app-backend-v4-routing

package/core/_type.ts

@@ -0,0 +1,110 @@
+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 const response = <R extends z.ZodObject<any> | z.ZodArray<any> | z.ZodNull>(data: R) => {
+  return z
+    .object({
+      data,
+      message: z.string().optional(),
+      status: z.number().optional(),
+      error: z.never().optional(),
+      success: z.literal(true),
+    })
+    .or(
+      z.object({
+        data: z.never(),
+        message: z.string(),
+        status: z.number().optional(),
+        error: z.object({
+          message: z.string(),
+          info: z.object({
+            status: z.number(),
+            code: z.string(),
+            messages: z.array(
+              z.object({
+                message: z.string(),
+                rule: z.string().optional(),
+                field: z.string().optional(),
+              })
+            ),
+          }),
+        }),
+        success: z.never(),
+      })
+    )
+}
+
+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 const IApiType = <T extends NestedRoute>(api: T) => api
+
+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"]>>
+}
+
+// Awaited<ReturnType<IRouterApi["user"]["commission"]["get"]>>["data"]
+
+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
+}

package/core/_untils.ts

@@ -0,0 +1,142 @@
+import { join } from "node:path"
+import axios from "axios"
+import { IRoute, IRouteFunction, IRouteGroup, IRouterApi } from "./_type"
+import { NestedRoute } from "./_type"
+import { z } from "zod"
+
+let host: string | undefined
+let baseUrl: string | undefined
+
+export const apiUrlBuilder = (segment = "", baseUrl = "", host = "") => {
+  const path = join(baseUrl, segment)
+  return host + path
+}
+
+export const apiFetch = {
+  setHostApi: (h: string) => {
+    host = h
+  },
+  setBaseUrl: (b: string) => {
+    baseUrl = b
+  },
+
+  fetch: async (
+    urlInput: string,
+    method?: RequestInit["method"] | undefined,
+    body?: unknown,
+    searchParams?: unknown,
+    queryParams?: {
+      [key: string]: string
+    }
+  ) => {
+    let url = apiUrlBuilder(urlInput, baseUrl, host)
+    if (queryParams) {
+      for (const [key, value] of Object.entries(queryParams)) {
+        url = url.replace(`:${key}`, value)
+      }
+    }
+    if (searchParams) {
+      const searchParamsString = new URLSearchParams(searchParams as Record<string, string>).toString()
+      url += `?${searchParamsString}`
+    }
+    const res = await axios({
+      method,
+      url,
+      data: body,
+    })
+    return res.data
+  },
+}
+
+export const isRoute = (value: NestedRoute | IRoute): value is IRoute => {
+  return "method" in value
+}
+
+export const isSubRoute = (value: NestedRoute | IRoute): value is NestedRoute => {
+  return !isRoute(value)
+}
+
+export const parseApiRoute = <T extends NestedRoute | IRoute, K extends IRouteGroup>(
+  key: string | undefined,
+  subRoute: T,
+  result: K,
+  hostApi: string,
+  basePath: string
+) => {
+  apiFetch.setHostApi(hostApi)
+  apiFetch.setBaseUrl(basePath)
+  if (isRoute(subRoute) && key) {
+    const route = subRoute
+    if (route.body) {
+      if (route.searchParams) {
+        if (route.params) {
+          ;(result as unknown as IRouteFunction) = (
+            body: typeof route.body extends z.ZodObject<any> ? z.infer<typeof route.body> : undefined,
+            searchParams: typeof route.searchParams extends z.ZodObject<any>
+              ? z.infer<typeof route.searchParams>
+              : undefined,
+            queryParams: typeof route.params extends z.ZodObject<any> ? z.infer<typeof route.params> : undefined
+          ) => apiFetch.fetch(route.url, route.method, body, searchParams, queryParams)
+        } else {
+          ;(result as unknown as IRouteFunction) = (
+            body: typeof route.body extends z.ZodObject<any> ? z.infer<typeof route.body> : undefined,
+            searchParams: typeof route.searchParams extends z.ZodObject<any>
+              ? z.infer<typeof route.searchParams>
+              : undefined
+          ) => apiFetch.fetch(route.url, route.method, body, searchParams)
+        }
+      } else {
+        if (route.params) {
+          ;(result as unknown as IRouteFunction) = (
+            body: typeof route.body extends z.ZodObject<any> ? z.infer<typeof route.body> : undefined,
+            queryParams: typeof route.params extends z.ZodObject<any> ? z.infer<typeof route.params> : undefined
+          ) => apiFetch.fetch(route.url, route.method, body, undefined, queryParams)
+        } else {
+          ;(result as unknown as IRouteFunction) = (
+            body: typeof route.body extends z.ZodObject<any> ? z.infer<typeof route.body> : undefined
+          ) => apiFetch.fetch(route.url, route.method, body)
+        }
+      }
+    } else if (route.searchParams) {
+      if (route.params) {
+        ;(result as unknown as IRouteFunction) = (
+          searchParams: typeof route.searchParams extends z.ZodObject<any>
+            ? z.infer<typeof route.searchParams>
+            : undefined,
+          queryParams: typeof route.params extends z.ZodObject<any> ? z.infer<typeof route.params> : undefined
+        ) => apiFetch.fetch(route.url, route.method, undefined, searchParams, queryParams)
+      } else {
+        ;(result as unknown as IRouteFunction) = (
+          searchParams: typeof route.searchParams extends z.ZodObject<any>
+            ? z.infer<typeof route.searchParams>
+            : undefined
+        ) => apiFetch.fetch(route.url, route.method, undefined, searchParams)
+      }
+    } else {
+      if (route.params) {
+        ;(result as unknown as IRouteFunction) = (
+          queryParams: typeof route.params extends z.ZodObject<any> ? z.infer<typeof route.params> : undefined
+        ) => apiFetch.fetch(route.url, route.method, undefined, undefined, queryParams)
+      } else {
+        ;(result as unknown as IRouteFunction) = () => apiFetch.fetch(route.url, route.method)
+      }
+    }
+  } else if (isSubRoute(subRoute)) {
+    for (const [key, value] of Object.entries(subRoute)) {
+      ;(result as IRouteGroup)[key] = parseApiRoute(
+        key,
+        value as NestedRoute | IRoute,
+        ((result as IRouteGroup)[key] ?? {}) as IRouteGroup,
+        hostApi,
+        basePath
+      )
+    }
+  }
+  return result
+}
+
+export const parseApiRoutes = <T extends NestedRoute>(api: T, hostApi: string, basePath: string) => {
+  const result = {} as IRouterApi
+  const response = parseApiRoute(undefined, api, result, hostApi, basePath)
+  return response
+}

package/core/index.ts

@@ -0,0 +1,15 @@
+import { opsRoutes } from "routes/ops"
+import { adminRoutes } from "./../routes/admin"
+import { publicRoutes } from "./../routes/public"
+import { userRoutes } from "./../routes/user"
+import { IApiType } from "./_type"
+import { driverRoutes } from "routes/driver"
+
+export const index = IApiType({
+  user: userRoutes,
+  public: publicRoutes,
+  admin: adminRoutes,
+  ops: opsRoutes,
+  driver: driverRoutes,
+})
+export type ApiService = typeof index

package/eslint.config.js

@@ -0,0 +1,50 @@
+const importPlugin = require("eslint-plugin-import")
+const simpleImportSort = require("eslint-plugin-simple-import-sort")
+const unusedImports = require("eslint-plugin-unused-imports")
+const typescriptPlugin = require("@typescript-eslint/eslint-plugin")
+const typescriptParser = require("@typescript-eslint/parser")
+
+module.exports = [
+  {
+    files: ["**/*.ts"],
+    languageOptions: {
+      parser: typescriptParser,
+      parserOptions: {
+        project: "./tsconfig.json",
+        sourceType: "module",
+      },
+    },
+    plugins: {
+      import: importPlugin,
+      "simple-import-sort": simpleImportSort,
+      "unused-imports": unusedImports,
+      "@typescript-eslint": typescriptPlugin,
+    },
+    rules: {
+      "unused-imports/no-unused-imports": "error",
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+        },
+      ],
+      "max-params": ["error", 6],
+      "simple-import-sort/imports": "off",
+      "simple-import-sort/exports": "off",
+      "no-console": ["error", { allow: ["warn", "error"] }],
+    },
+    settings: {
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true,
+          project: "./tsconfig.json",
+        },
+      },
+      node: {
+        extensions: [".ts", ".js", ".json"],
+      },
+    },
+    ignores: ["node_modules", "build", "packages/**"],
+  },
+]

package/index.ts

@@ -0,0 +1,131 @@
+import { parseApiRoutes } from "core/_untils"
+import { index } from "./core/index"
+import { IRouterApi } from "core/_type"
+
+export class APIRouter {
+  private hostApi: string
+  private basePath: string
+  public rt: IRouterApi
+
+  constructor(hostApi: string, basePath: string) {
+    this.hostApi = hostApi
+    this.basePath = basePath
+    this.rt = parseApiRoutes(index, this.hostApi, this.basePath)
+  }
+
+  setHostApi(hostApi: string) {
+    this.hostApi = hostApi
+    this.rt = parseApiRoutes(index, this.hostApi, this.basePath)
+  }
+
+  setBasePath(basePath: string) {
+    this.basePath = basePath
+    this.rt = parseApiRoutes(index, this.hostApi, this.basePath)
+  }
+
+  routes() {
+    return this.rt
+  }
+
+  getHostApi() {
+    return this.hostApi
+  }
+
+  getBasePath() {
+    return this.basePath
+  }
+}
+
+// Demo use
+// exemple
+// import { IContact, IContactCreateByUser, IPaginationData } from "models"
+
+// const api = new APIRouter("http://localhost:3000", "/api/v1")
+
+// try {
+//  const { success, data, error, message } = await api.routes().user.contact.liste({
+//   searchParams: {
+//     page: 1,
+//     limit: 10,
+//     search: "John",
+//     sortBy: "createdAt",
+//     direction: "asc",
+//   }
+//  })
+//   if (success) {
+//     console.log(data)
+//     const finalData: IPaginationData<IContact> = data
+//     console.log(finalData.meta.currentPage)
+//     console.log(finalData.meta.perPage)
+//     console.log(finalData.meta.total)
+//     console.log(finalData.meta.lastPage)
+//     console.log(finalData.meta.firstPage)
+//     console.log(finalData.meta.lastPageUrl)
+//     console.log(finalData.meta.nextPageUrl)
+//     console.log(finalData.meta.previousPageUrl)
+//     console.log(finalData.meta.firstPageUrl)
+
+//     console.log(finalData.data.map((item: IContact) => item.fullName))
+//   } else {
+//     console.log(error, message)
+//   }
+// } catch (error) {
+//   console.log(error)
+// }
+
+// try {
+//   const { success, data, error, message } = await api.routes().user.contact.detail({
+//     queryParams: {
+//       id: "1",
+//     }
+//   })
+//   if (success) {
+//     console.log(data)
+//     const finalData: IContact = data
+//     console.log(finalData.fullName)
+//   } else {
+//     console.log(error, message)
+//   }
+// } catch (error) {
+//   console.log(error)
+// }
+
+// try {
+//   const input: IContactCreateByUser = {
+//     fullName: "John Doe",
+//     firstName: "John",
+//     lastName: "Doe",
+//     emailOne: "john.doe@example.com",
+//     address: "123 Main St, Anytown, USA",
+//     city: "Anytown",
+//     countryId: 1,
+//     isParis: true,
+//     isMedical: true,
+//     isService: true,
+//     addressOne: "123 Main St, Anytown, USA",
+//     postalCode: "12345",
+//     numCode: "12345",
+//     telephoneOne: "1234567890",
+//     company: "John Doe",
+//     typeContact: "John Doe",
+//     addressTwo: "123 Main St, Anytown, USA",
+//     civility: "John Doe",
+//     numCodeOne: "12345",
+//     numCodeTwo: "12345",
+//     telephoneTwo: "1234567890",
+//     emailTwo: "john.doe@example.com",
+//     comments: "John Doe",
+//   }
+//   const { success, data, error, message } = await api.routes().user.contact.create({
+//     body: input,
+//   })
+//   if (success) {
+//     console.log(data)
+//     const finalData: IContact = data
+//     console.log(finalData.fullName)
+//   } else {
+//     console.log(error, message)
+//   }
+// } catch (error) {
+//   console.log(error)
+// }

package/models/_banniere.ts

@@ -0,0 +1,33 @@
+import { z } from "zod"
+import { DateTime } from "luxon"
+
+export const BanniereSchema = z.object({
+  id: z.number(),
+  createdAt: z.date().transform((date) => DateTime.fromJSDate(date)),
+  updatedAt: z.date().transform((date) => DateTime.fromJSDate(date)),
+  libelle: z.string().nullable(),
+  contenus: z.string().nullable(),
+  imageUrl: z.string().nullable(),
+  active: z.boolean(),
+  withImage: z.boolean(),
+})
+
+export const BanniereCreateSchema = z.object({
+  libelle: z.string(),
+  contenus: z.string(),
+  image: z.any().optional(), // Pour le file upload
+  active: z.boolean(),
+  withImage: z.boolean(),
+})
+
+export const BanniereUpdateSchema = z.object({
+  libelle: z.string().optional(),
+  contenus: z.string().optional(),
+  image: z.any().optional(), // Pour le file upload
+  withImage: z.boolean().optional(),
+  active: z.boolean().optional(),
+})
+
+export type IBanniere = z.infer<typeof BanniereSchema>
+export type IBanniereCreate = z.infer<typeof BanniereCreateSchema>
+export type IBanniereUpdate = z.infer<typeof BanniereUpdateSchema>