@zauru-sdk/services 1.0.4

package/dist/zauru/zauru-profiles.server.d.ts

@@ -0,0 +1,167 @@
+import type { Session } from "@remix-run/node";
+import type { AxiosUtilsResponse } from "./httpZauru.server.js";
+import { EmployeeGraphQL } from "@zauru-sdk/graphql";
+interface Logo {
+    url: null | string;
+    thumb: {
+        url: null | string;
+    };
+    standard: {
+        url: null | string;
+    };
+    header: {
+        url: null | string;
+    };
+}
+export type OauthProfile = {
+    id: number;
+    uid: number;
+    username: string;
+    name: string;
+    time_zone: string;
+    mobile_phone: string;
+    admin: boolean;
+    selected_entity: number;
+    selected_entity_name: string;
+    selected_entity_logo: string;
+    selected_entity_role: number;
+    employee_id: number;
+    crm_admin: boolean;
+    crm_supervisor: boolean;
+    crm_user: boolean;
+    currency_id: number;
+    currency_name: string;
+    currency_prefix: string;
+    api_key: string;
+    scope: string;
+    email: string;
+};
+interface Entity {
+    id: number;
+    name: string;
+    tin: string;
+    country: string;
+    currency_id: number;
+    entity_type_id: number;
+    industry: string;
+    web: string;
+    notes: string;
+    vat: number;
+    vat_included: boolean;
+    logo: Logo;
+    logo_2: Logo;
+    created_at: string;
+    updated_at: string;
+    distributor: number;
+    costing_method: string;
+    address: string;
+    state: string;
+    city: string;
+    income_tax: number;
+    report_logo: Logo;
+    distributor_contract_id: number | null;
+    producer_contract_id: number | null;
+    legal_representative_name: string | null;
+    legal_representative_identification: string | null;
+    legal_representative_birthday: string | null;
+    legal_representative_gender: boolean;
+    legal_representative_marital_status: string | null;
+    legal_representative_occupation: string | null;
+    legal_representative_nationality: string | null;
+    exporter_code: string | null;
+}
+export type Agency = {
+    id: number;
+    zid: number;
+    active: boolean;
+    ean13: string;
+    name: string;
+    employee_id: number | null;
+    updater_id: number;
+    entity_id: number;
+    virtual: boolean;
+    virtual_type: string | null;
+    warehouse: boolean;
+    point_of_sale: boolean;
+    workshop: boolean;
+    factory: boolean;
+    contact: string;
+    city: string;
+    address_line_1: string;
+    address_line_2: string;
+    phone: string;
+    notes: string;
+    created_at: string;
+    updated_at: string;
+    price_list_id: number | null;
+    quote: boolean;
+    ecommerce: boolean;
+    external_storage_service_name: string;
+    agency_category_id: number | null;
+};
+export type Membership = {
+    id: number;
+    active: boolean;
+    current: boolean;
+    reference: string;
+    starts: string;
+    expires: string;
+    eternal: boolean;
+    entity_id: number;
+    notes: string;
+    created_at: string;
+    updated_at: string;
+    licenses_count: number;
+    entity: Entity;
+};
+type Profile = {
+    id: number;
+    email: string;
+    active: boolean;
+    admin: boolean;
+    name: string;
+    address: null | string;
+    mobile_phone: string;
+    birthday: null | string;
+    gender: boolean;
+    notes: null | string;
+    time_zone: string;
+    language: string;
+    selected_entity_id: number;
+    created_at: string;
+    updated_at: string;
+    authentication_token: string;
+    provider: string;
+    provider_token: string;
+};
+export type ProfileResponse = {
+    profile: Profile;
+    memberships: Membership[];
+};
+/**
+ * getOauthUserInfo
+ * @param codeValue
+ * @returns
+ */
+export declare const getOauthUserInfo: (codeValue: string) => Promise<AxiosUtilsResponse<OauthProfile>>;
+/**
+ *
+ * @param employeeId
+ * @param headers
+ * @returns
+ */
+export declare const getEmployeeInfo: (id: number, headers: any) => Promise<AxiosUtilsResponse<EmployeeGraphQL>>;
+/**
+ * getProfileInformation
+ * @param headers
+ * @returns
+ */
+export declare const getProfileInformation: (headers: any) => Promise<AxiosUtilsResponse<ProfileResponse>>;
+export declare const changeEntity: (headers: any, entityId: string) => Promise<any>;
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export declare const getAgencyInfo: (headers: any, session: Session) => Promise<AxiosUtilsResponse<Agency>>;
+export {};

package/dist/zauru/zauru-profiles.server.js

@@ -0,0 +1,68 @@
+import httpZauru, { handlePossibleAxiosErrors } from "./httpZauru.server.js";
+import httpOauth from "./httpOauth.server.js";
+import { config } from "@zauru-sdk/config";
+/**
+ * getOauthUserInfo
+ * @param codeValue
+ * @returns
+ */
+export const getOauthUserInfo = async (codeValue) => {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpOauth.get(`/api/userinfo`, {
+            headers: {
+                Authorization: `Bearer ${codeValue}`,
+            },
+        });
+        return response.data;
+    });
+};
+/**
+ *
+ * @param employeeId
+ * @param headers
+ * @returns
+ */
+export const getEmployeeInfo = async (id, headers) => {
+    return handlePossibleAxiosErrors(async () => {
+        const employeeInfo = await httpZauru.get(`/settings/employees/${id}.json`, { headers });
+        return employeeInfo.data;
+    });
+};
+/**
+ * getProfileInformation
+ * @param headers
+ * @returns
+ */
+export const getProfileInformation = async (headers) => {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.get(`/profile.json`, {
+            headers,
+        });
+        return response.data;
+    });
+};
+export const changeEntity = async (headers, entityId) => {
+    const changeEntityFetch = await httpZauru.patch(`${config.zauruBaseURL}/company.json`, JSON.stringify({
+        selected_entity_id: entityId,
+    }), {
+        headers,
+    });
+    return changeEntityFetch.data;
+};
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export const getAgencyInfo = async (headers, session) => {
+    return handlePossibleAxiosErrors(async () => {
+        const agency_id = session.get("agency_id");
+        if (!agency_id) {
+            throw new Error("No hay una agencia asignada para este usuario... Contacte con su administrador.");
+        }
+        const response = await httpZauru.get(`/settings/agencies/${agency_id}.json`, {
+            headers,
+        });
+        return response?.data;
+    });
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@zauru-sdk/services",
+  "version": "1.0.4",
+  "description": "Configuración centralizada para aplicaciones Zauru SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Oscar Cuéllar",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@remix-run/node": "^2.8.1",
+    "@zauru-sdk/config": "^1.0.4",
+    "@zauru-sdk/graphql": "^1.0.4",
+    "axios": "^1.6.7",
+    "chalk": "5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "gitHead": "75cef0c437edf8240adc811bc7b395e1030adf90"
+}

package/src/common.server.ts

@@ -0,0 +1,293 @@
+import { Session, redirect } from "@remix-run/node";
+import { commitSession, getSession } from "./sessions/sessions.server.js";
+import { AxiosRequestHeaders } from "axios";
+import chalk from "chalk";
+import httpZauru, {
+  AxiosUtilsResponse,
+  handlePossibleAxiosErrors,
+} from "./zauru/httpZauru.server.js";
+import {
+  Agency,
+  OauthProfile,
+  ProfileResponse,
+  getAgencyInfo,
+  getEmployeeInfo,
+  getOauthUserInfo,
+  getProfileInformation,
+} from "./zauru/zauru-profiles.server.js";
+import { EmployeeGraphQL } from "@zauru-sdk/graphql";
+
+/**
+ * loginWebApp
+ * @param session
+ * @param codeValue
+ * @param cookie
+ * @returns
+ */
+export const loginWebApp = async (
+  session: Session,
+  codeValue: string,
+  cookie: string
+): Promise<
+  AxiosUtilsResponse<{
+    headers: any;
+    oauthProfile: OauthProfile;
+    employeeProfile: EmployeeGraphQL;
+    userProfile: ProfileResponse;
+    agencyProfile: Agency;
+  }>
+> => {
+  return handlePossibleAxiosErrors(async () => {
+    const userInfoResponse = await getOauthUserInfo(codeValue ?? "");
+    if (userInfoResponse.error) {
+      throw new Error(userInfoResponse.userMsg);
+    }
+
+    const userInfo = userInfoResponse.data;
+    session.set("username", userInfo?.username);
+    session.set("token", userInfo?.api_key);
+    session.set("code", codeValue);
+    session.set("name", userInfo?.name);
+    session.set("email", userInfo?.email);
+    session.set("employee_id", userInfo?.employee_id);
+
+    const headers = await getHeaders(cookie, session, {
+      token: userInfo?.api_key ?? "",
+      username: userInfo?.username ?? "",
+    });
+
+    const res_emp = await getEmployeeInfo(userInfo?.employee_id ?? 0, headers);
+    if (res_emp.error) {
+      throw new Error(res_emp.userMsg);
+    }
+
+    const empInfo = res_emp.data;
+    session.set("agency_id", empInfo?.agency_id);
+    session.set("email", empInfo?.email);
+    session.set("selectedEntity", empInfo?.entity_id);
+
+    const profileInfoResponse = await getProfileInformation(headers);
+    if (profileInfoResponse.error) {
+      throw new Error(profileInfoResponse.userMsg);
+    }
+    const profileInfo = profileInfoResponse.data;
+
+    if (!profileInfo?.memberships?.length) {
+      throw new Error("El usuario no tiene suscripciones...");
+    }
+
+    const membership = profileInfo?.memberships?.filter(
+      (member: any) => member?.entity?.id === empInfo?.entity_id
+    );
+
+    if (!membership) {
+      throw new Error(
+        "No se encontró una suscripción para este usuario en la entidad asignada."
+      );
+    }
+
+    if (membership?.length)
+      session.set("entityName", membership[0]?.entity?.name);
+
+    const agencyInfoResponse = await getAgencyInfo(headers, session);
+    if (agencyInfoResponse.error) {
+      throw new Error(agencyInfoResponse.userMsg);
+    }
+    session.set("agency_name", agencyInfoResponse.data?.name);
+
+    return {
+      headers,
+      oauthProfile: userInfo as OauthProfile,
+      employeeProfile: empInfo as EmployeeGraphQL,
+      userProfile: profileInfo as ProfileResponse,
+      agencyProfile: agencyInfoResponse.data as Agency,
+    };
+  });
+};
+
+export type GraphQLToken = {
+  status: number;
+  message: string;
+  token: string;
+  expires: string;
+  expiresMsg: string;
+  graphqlUrl: string;
+};
+
+/**
+ * Obtiene los headers que se usan en todos los endpoints de zauru
+ * @param cookie
+ * @param _session La session es opcional, se envía sólo si ya se tiene a la mano, para ya no volverla a consultar.
+ * @returns
+ */
+export const getHeaders = async (
+  cookie: string | null,
+  _session?: Session | null,
+  config?: { token: string; username: string } | null,
+  extraConfig?: { withOutContentType: string }
+) => {
+  // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Session and Header Info<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+  const session = _session ?? (await getSession(cookie));
+
+  if (!session.has("username") && !config) {
+    redirect("/");
+    return {};
+  }
+
+  const headers = {
+    "X-User-Email": config?.username ?? session.get("username"),
+    "X-User-Token": config?.token ?? session.get("token"),
+    "Content-type": "application/json",
+    Accept: "application/json",
+  } as { [key: string]: string };
+
+  if (extraConfig?.withOutContentType) {
+    delete headers["Content-type"];
+  }
+
+  return headers;
+};
+
+/**
+ * getGraphQLToken
+ * @param session
+ * @returns
+ */
+async function getGraphQLToken(
+  session: Session
+): Promise<AxiosUtilsResponse<GraphQLToken>> {
+  return handlePossibleAxiosErrors(async () => {
+    const token = (await session.get("graphqlToken")) as GraphQLToken;
+    const headers = (await getHeaders(null, session)) as any;
+
+    const tokenHasExpired =
+      token &&
+      token.expires &&
+      new Date(new Date().getTime() - 3 * 60 * 60 * 1000) >=
+        new Date(token.expires);
+
+    //Si no hay token, es la primera vez que se recibe, lo voy a traer de zauru
+    if (!token || tokenHasExpired) {
+      tokenHasExpired
+        ? console.log(
+            chalk.yellow(
+              `=============== ⚠️ EL TOKEN GRAPHQL ESTÁ EXPIRADO ⚠️ ====================`
+            )
+          )
+        : console.log(
+            chalk.yellow(
+              `=============== ⚠️ NO HAY UN TOKEN GRAPHQL GUARDADO ⚠️ ====================`
+            )
+          );
+
+      const responseToken = await httpZauru.get<GraphQLToken>(
+        "/apps/graphql.json",
+        {
+          headers,
+        }
+      );
+
+      if (responseToken.data) {
+        session.set("graphqlToken", responseToken.data);
+        await commitSession(session);
+        console.log(
+          chalk.green(
+            `=============== ✅ TOKEN GRAPHQL GUARDADO EN SESION Y DEVUELTO ✅ ====================`
+          )
+        );
+        return responseToken.data;
+      }
+
+      console.log(
+        chalk.red(
+          `=============== ❗ NO HAY INFORMACIÓN OBTENIDA DEL REQUEST A ZAURU - GET_TOKEN ❗ ====================`
+        )
+      );
+      throw new Error(
+        "No viene información en la solicitud de getGraphQLToken a Zauru"
+      );
+    }
+
+    //Si ya está guardado un token en la sesión y aún no a expirado.
+    return token;
+  });
+}
+
+/**
+ * getGraphQLAPIHeaders
+ * @param session
+ * @returns
+ */
+export const getGraphQLAPIHeaders = async (session: Session) => {
+  const { data: token, error, userMsg } = await getGraphQLToken(session);
+
+  if (error) {
+    console.log(
+      chalk.red(
+        `=============== ❗ OCURRIÓ UN ERROR DEL REQUEST A ZAURU - GET_TOKEN ❗ ==================== ${userMsg}`
+      )
+    );
+    return {
+      Authorization: `Bearer token_no_existe`,
+      "Content-Type": "application/json",
+    } as AxiosRequestHeaders;
+  }
+
+  return {
+    Authorization: `Bearer ${token?.token}`,
+    "Content-Type": "application/json",
+  } as AxiosRequestHeaders;
+};
+
+export type SessionMessage = { id: string; title: string; message: string };
+export const saveSessionMessage = async (
+  session: Session,
+  info: SessionMessage
+): Promise<void> => {
+  const updateTasks = (session.get("sessionMessages") ??
+    []) as SessionMessage[];
+  session.set("updateTasks", [...updateTasks, info]);
+  await commitSession(session);
+};
+
+export const deleteSessionMessage = async (
+  session: Session,
+  id: string
+): Promise<boolean> => {
+  let updateTasks = session.get("sessionMessages") as Array<SessionMessage>;
+  if (
+    Array.isArray(updateTasks) &&
+    updateTasks.some((task: SessionMessage) => task.id === id)
+  ) {
+    //La elimino de la lista
+    updateTasks = updateTasks.filter((task) => task.id !== id);
+    session.set("sessionMessages", updateTasks);
+    await commitSession(session);
+    return true;
+  }
+  return false;
+};
+
+function generarUUID() {
+  // Retorna un arreglo de 9 bytes con valores aleatorios
+  const array = new Uint8Array(9);
+  crypto.getRandomValues(array);
+
+  // Convertir Uint8Array a array normal
+  const normalArray = Array.from(array);
+
+  // Codificación en base 64
+  const base64 = btoa(String.fromCharCode.apply(null, normalArray))
+    .replace("+", "0") // Reemplaza caracteres no alfanuméricos
+    .replace("/", "1")
+    .substring(0, 11); // Acorta a 11 caracteres
+
+  return base64;
+}
+
+// Función para generar un código de producto a partir de un UUID
+export function generateDistinctCode(prefix: string) {
+  const uuid = generarUUID();
+  const codigoProducto = `${prefix}-${uuid}`;
+  return codigoProducto;
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from "./common.server.js";
+
+export * from "./sessions/sessions.server.js";
+export * from "./sessions/upstash.server.js";
+
+export * from "./zauru/httpGraphQL.server.js";
+export * from "./zauru/httpOauth.server.js";
+export * from "./zauru/httpZauru.server.js";
+
+export * from "./zauru/zauru-agencies.server.js";
+export * from "./zauru/zauru-profiles.server.js";

package/src/sessions/sessions.server.ts

@@ -0,0 +1,17 @@
+import { createCookie } from "@remix-run/node";
+import { createUpstashSessionStorage } from "./upstash.server.js";
+
+const sessionCookie = createCookie("_rj_session", {
+  secrets: ["r3m1xr0ck1"],
+  path: "/",
+  sameSite: process.env.NODE_ENV === "production" ? "none" : "lax",
+  httpOnly: true,
+  maxAge: 60 * 60 * 24,
+  //expires,
+  secure: process.env.NODE_ENV === "production",
+});
+
+const { getSession, commitSession, destroySession } =
+  createUpstashSessionStorage({ cookie: sessionCookie });
+
+export { getSession, commitSession, destroySession };

package/src/sessions/upstash.server.ts

@@ -0,0 +1,55 @@
+import { createSessionStorage } from "@remix-run/node";
+import crypto from "crypto";
+import { config } from "@zauru-sdk/config";
+
+const redisBaseURL = config.redisBaseURL;
+
+const headers = {
+  Authorization: `Bearer ${config.redisToken}`,
+  Accept: "application/json",
+  "Content-Type": "application/json",
+};
+
+const expiresToSeconds = (expires: Date | undefined) => {
+  return 3600 * 8;
+};
+
+// For more info check https://remix.run/docs/en/v1/api/remix#createsessionstorage
+export function createUpstashSessionStorage({ cookie }: any) {
+  return createSessionStorage({
+    cookie,
+    async createData(data, expires) {
+      const id: string = crypto.randomUUID();
+      await fetch(`${redisBaseURL}/set/${id}?EX=${expiresToSeconds(expires)}`, {
+        method: "post",
+        body: JSON.stringify({ data }),
+        headers,
+      });
+      return id;
+    },
+    async readData(id) {
+      const response = await fetch(`${redisBaseURL}/get/${id}`, {
+        headers,
+      });
+      try {
+        const { result } = (await response.json()) as any;
+        return JSON.parse(result).data;
+      } catch (error) {
+        return null;
+      }
+    },
+    async updateData(id, data, expires) {
+      await fetch(`${redisBaseURL}/set/${id}?EX=${expiresToSeconds(expires)}`, {
+        method: "post",
+        body: JSON.stringify({ data }),
+        headers,
+      });
+    },
+    async deleteData(id) {
+      await fetch(`${redisBaseURL}/del/${id}`, {
+        method: "post",
+        headers,
+      });
+    },
+  });
+}

package/src/zauru/httpGraphQL.server.ts

@@ -0,0 +1,55 @@
+import axios from "axios";
+import chalk from "chalk";
+import { config } from "@zauru-sdk/config";
+
+const axiosInstance = axios.create({
+  baseURL: `${config.graphqlAPIBaseURL}`,
+});
+
+axiosInstance.interceptors.request.use(
+  function (request) {
+    // Do something before request is sent
+    console.log("---------------- EJECUTANDO REQUEST GRAPHQL ----------------");
+    //console.time(`${request.baseURL}${request.url}`);
+    console.log(chalk.green(`${request.baseURL}${request.url}`));
+    request.timeout = 120000;
+
+    return request;
+  },
+  function (error) {
+    console.log(
+      chalk.red("---------------- ERROR CON REQUEST GRAPHQL ----------------")
+    );
+    console.log(`${error}`);
+    // Do something with request error
+    return Promise.reject(error);
+  }
+);
+
+// Add a response interceptor
+axiosInstance.interceptors.response.use(
+  function (response) {
+    // Do something with response data
+    //console.timeEnd(`${response.config.baseURL}${response.config.url}`);
+    return response;
+  },
+  function (error) {
+    console.log(
+      chalk.red("---------------- ERROR CON REQUEST GRAPHQL ----------------")
+    );
+    console.log(`${error}`);
+    // Do something with response error
+    const { response } = error;
+    const msgError = response
+      ? `HTTP ${response.status} ${response.statusText} - URL: ${
+          response?.config?.baseURL
+        }${response?.config?.url} - ${JSON.stringify(response?.data)}`
+      : error;
+    console.log(chalk.red(`${msgError}`));
+    throw new Error(msgError);
+  }
+);
+
+const httpGraphQLAPI = axiosInstance;
+
+export default httpGraphQLAPI;