import DuploTo from "@duplojs/to";

// client http
const duploTo = new DuploTo();

const requestor = duploTo.request(
    "/user/{id}",
    {
        method: "GET",
        params: {id: 2},
    }
);
const result = await requestor.result // resultat de la request

const result = await duploTo.patch(
    "/user/{id}/firstname",
    "Mathieu"
    {params: {id: 50}}
)
.result;

const data = await duploTo.get(
    "/users",
    {query: {limit: 20}}
)
.sd();

await duploTo.get(
    "/user/{id}",
    {params: {id: 789}}
)
.info("user.get", (data) => {
    // some action when response holds info 'user.get'
})
.s((data) => {
    // some action when response is successfull
})
.code(200, (data) => {
    // some action when response has status 200
})
.e((data) => {
    // some action when response is wrong
})
.result;

const duploTo = new DuploTo({
    prefix: "api", 
    host: "duplo.campani.fr",
    https: true,
});

interface InterceptorParams{
    enabledLoader?: boolean
}

const duploTo = new DuploTo<InterceptorParams>();

duploTo.setRequestInterceptor((request, params) => {
    // params === InterceptorParams
    return request;
});

duploTo.setResponseInterceptor((response, request, params) => {
    // params === InterceptorParams
    return response;
});

duploTo.setDefaultHeaders({
    get token(){
        return "my super tokent"
    }
});

duploTo.addHookInfo(
    "user.connect",
    () => {
        // action
    }
)

const requestor = await duploTo.get(
    "/users",
    {query: {limit: 20}}
)

duploTo.request(
    "/user/{id}",
    {
        method: "GET",
        params: {id: 2},
    }
)
.s((data) => {
    // some action when response is successfull
})
.result;

await duploTo.get(
    "/users",
    {query: {limit: 10}}
)
.info("users.get", () => {
    // some action when response holds info 'users.get'
})
.result;

await duploTo.patch(
    "/user/{id}/firstname",
    "Mathieu",
    {params: {id: 63}}
)
.code(200, () => {
    // some action when response has status 200
})
.result;

const data = await duploTo.put(
    "/user/{id}",
    {
        firstname: "Mathieu",
        lastname: "Campani",
    },
    {
        params: {id: 30},
        headers: {token: "mon super token"}
    }
)
.sd();

import Duplo from "@duplojs/duplojs";
import duploTypeGenerator from "@duplojs/to/plugin";

const duplo = Duplo({
    port: 1506, 
    host: "localhost", 
    environment: "DEV"
});

/* ... */

duplo.use(duploTypeGenerator, {
    outputFile: "EnrichedDuploTo.ts"
});

import DuploTo from "@duplojs/to";
import type {EnrichedDuploTo} from "/path/to/EnrichedDuploTo";

interface InterceptorParams {
    // ...
}

export const duploTo = new DuploTo<
    InterceptorParams, 
    EnrichedDuploTo<InterceptorParams>
>({
    // ...
});

duploTo.enriched //This property has all declaration.

//ramdom route in api

duplo
.declareRoute("GET", "/user/{id}")
.extract({
    params: {
        id: zod.string(),
    },
    headers: {
        token: zod.string().ignore(), // field is ignore by type generator
    }
})
.handler(({}, res) => {
    res.code(200).info("user.get").send({firstname: "mathieu"});
});

duplo
.declareRoute("GET", "/user/{id}")
.extract({
    // ...
})
.handler(
    ({}, res) => {
        res.code(200).info("user.get").send({firstname: "mathieu"});
    },
    new IHaveSentThis(200, "user.get", zod.object({firstname: zod.string()}))
);