washday-sdk 1.6.54 → 1.6.56

package/dist/api/googleMaps/index.js

@@ -0,0 +1 @@
+export * as postModule from "./post";

package/dist/api/googleMaps/post.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const GOOGLE_MAPS_PROXY = "api/v2/google-maps";
+const CUSTOMERS_APP_GOOGLE_MAPS_PROXY = "api/v2/washdayapp/google-maps";
+function authConfig() {
+    return {
+        headers: { Authorization: `Bearer ${this.apiToken}` },
+    };
+}
+export const autocompleteCustomersApp = function (payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.axiosInstance.post(`${CUSTOMERS_APP_GOOGLE_MAPS_PROXY}/autocomplete`, payload, authConfig.call(this));
+    });
+};
+export const placeDetailsCustomersApp = function (payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.axiosInstance.post(`${CUSTOMERS_APP_GOOGLE_MAPS_PROXY}/place-details`, payload, authConfig.call(this));
+    });
+};
+export const geocodeCustomersApp = function (payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.axiosInstance.post(`${CUSTOMERS_APP_GOOGLE_MAPS_PROXY}/geocode`, payload, authConfig.call(this));
+    });
+};
+export const reverseGeocodeCustomersApp = function (payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.axiosInstance.post(`${CUSTOMERS_APP_GOOGLE_MAPS_PROXY}/reverse-geocode`, payload, authConfig.call(this));
+    });
+};
+export const autocomplete = function (payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.axiosInstance.post(`${GOOGLE_MAPS_PROXY}/autocomplete`, payload, authConfig.call(this));
+    });
+};
+export const placeDetails = function (payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.axiosInstance.post(`${GOOGLE_MAPS_PROXY}/place-details`, payload, authConfig.call(this));
+    });
+};
+export const geocode = function (payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.axiosInstance.post(`${GOOGLE_MAPS_PROXY}/geocode`, payload, authConfig.call(this));
+    });
+};
+export const reverseGeocode = function (payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.axiosInstance.post(`${GOOGLE_MAPS_PROXY}/reverse-geocode`, payload, authConfig.call(this));
+    });
+};

package/dist/api/index.js

@@ -47,6 +47,7 @@ import { getAxiosInstance } from "./axiosInstance";
 import * as integrationsEndpoints from './integrations';
 import * as updatesEndpoints from './updates';
 import * as intercomEndpoints from './intercom';
+import * as googleMapsEndpoints from './googleMaps';
 function bindMethods(instance, methods) {
     const boundMethods = {};
     for (const key in methods) {
@@ -223,6 +224,16 @@ const WashdayClient = function WashdayClient(apiToken, env = 'PROD', clientId, c
     this.config = bindMethods(this, {
         getTaxPresets: configEndpoints.getModule.getTaxPresets,
     });
+    this.googleMaps = bindMethods(this, {
+        autocompleteCustomersApp: googleMapsEndpoints.postModule.autocompleteCustomersApp,
+        placeDetailsCustomersApp: googleMapsEndpoints.postModule.placeDetailsCustomersApp,
+        geocodeCustomersApp: googleMapsEndpoints.postModule.geocodeCustomersApp,
+        reverseGeocodeCustomersApp: googleMapsEndpoints.postModule.reverseGeocodeCustomersApp,
+        autocomplete: googleMapsEndpoints.postModule.autocomplete,
+        placeDetails: googleMapsEndpoints.postModule.placeDetails,
+        geocode: googleMapsEndpoints.postModule.geocode,
+        reverseGeocode: googleMapsEndpoints.postModule.reverseGeocode,
+    });
     this.supplies = bindMethods(this, {
         getSupplies: getSupplies,
         getSupplyById: getSupplyById,

package/dist/index.js

@@ -5,4 +5,6 @@ export * from './interfaces/Config';
 export * from './interfaces/Cfdi';
 export * from './interfaces/Auth';
 export * from './interfaces/Customer';
+export * from './interfaces/DomainUrls';
+export * from './interfaces/GoogleMaps';
 export { WashdayClient, utils };

package/dist/interfaces/DomainUrls.js

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

package/dist/interfaces/GoogleMaps.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "washday-sdk",
-  "version": "1.6.54",
+  "version": "1.6.56",
   "description": "Washday utilities functions and API",
   "main": "dist/index.js",
   "type": "module",

package/src/api/googleMaps/index.ts

@@ -0,0 +1 @@
+export * as postModule from "./post";

package/src/api/googleMaps/post.ts

@@ -0,0 +1,108 @@
+import { WashdayClientInstance } from "../../interfaces/Api";
+import {
+  GoogleMapsAutocompletePayload,
+  GoogleMapsAutocompleteResponse,
+  GoogleMapsGeocodePayload,
+  GoogleMapsGeocodeResponse,
+  GoogleMapsPlaceDetailsPayload,
+  GoogleMapsPlaceDetailsResponse,
+  GoogleMapsReverseGeocodePayload,
+  GoogleMapsReverseGeocodeResponse,
+} from "../../interfaces/GoogleMaps";
+
+const GOOGLE_MAPS_PROXY = "api/v2/google-maps";
+const CUSTOMERS_APP_GOOGLE_MAPS_PROXY = "api/v2/washdayapp/google-maps";
+
+function authConfig(this: WashdayClientInstance) {
+  return {
+    headers: { Authorization: `Bearer ${this.apiToken}` },
+  };
+}
+
+export const autocompleteCustomersApp = async function (
+  this: WashdayClientInstance,
+  payload: GoogleMapsAutocompletePayload
+): Promise<GoogleMapsAutocompleteResponse> {
+  return await this.axiosInstance.post(
+    `${CUSTOMERS_APP_GOOGLE_MAPS_PROXY}/autocomplete`,
+    payload,
+    authConfig.call(this)
+  );
+};
+
+export const placeDetailsCustomersApp = async function (
+  this: WashdayClientInstance,
+  payload: GoogleMapsPlaceDetailsPayload
+): Promise<GoogleMapsPlaceDetailsResponse> {
+  return await this.axiosInstance.post(
+    `${CUSTOMERS_APP_GOOGLE_MAPS_PROXY}/place-details`,
+    payload,
+    authConfig.call(this)
+  );
+};
+
+export const geocodeCustomersApp = async function (
+  this: WashdayClientInstance,
+  payload: GoogleMapsGeocodePayload
+): Promise<GoogleMapsGeocodeResponse> {
+  return await this.axiosInstance.post(
+    `${CUSTOMERS_APP_GOOGLE_MAPS_PROXY}/geocode`,
+    payload,
+    authConfig.call(this)
+  );
+};
+
+export const reverseGeocodeCustomersApp = async function (
+  this: WashdayClientInstance,
+  payload: GoogleMapsReverseGeocodePayload
+): Promise<GoogleMapsReverseGeocodeResponse> {
+  return await this.axiosInstance.post(
+    `${CUSTOMERS_APP_GOOGLE_MAPS_PROXY}/reverse-geocode`,
+    payload,
+    authConfig.call(this)
+  );
+};
+
+export const autocomplete = async function (
+  this: WashdayClientInstance,
+  payload: GoogleMapsAutocompletePayload
+): Promise<GoogleMapsAutocompleteResponse> {
+  return await this.axiosInstance.post(
+    `${GOOGLE_MAPS_PROXY}/autocomplete`,
+    payload,
+    authConfig.call(this)
+  );
+};
+
+export const placeDetails = async function (
+  this: WashdayClientInstance,
+  payload: GoogleMapsPlaceDetailsPayload
+): Promise<GoogleMapsPlaceDetailsResponse> {
+  return await this.axiosInstance.post(
+    `${GOOGLE_MAPS_PROXY}/place-details`,
+    payload,
+    authConfig.call(this)
+  );
+};
+
+export const geocode = async function (
+  this: WashdayClientInstance,
+  payload: GoogleMapsGeocodePayload
+): Promise<GoogleMapsGeocodeResponse> {
+  return await this.axiosInstance.post(
+    `${GOOGLE_MAPS_PROXY}/geocode`,
+    payload,
+    authConfig.call(this)
+  );
+};
+
+export const reverseGeocode = async function (
+  this: WashdayClientInstance,
+  payload: GoogleMapsReverseGeocodePayload
+): Promise<GoogleMapsReverseGeocodeResponse> {
+  return await this.axiosInstance.post(
+    `${GOOGLE_MAPS_PROXY}/reverse-geocode`,
+    payload,
+    authConfig.call(this)
+  );
+};

package/src/api/index.ts

@@ -49,6 +49,7 @@ import { getAxiosInstance } from "./axiosInstance";
 import * as integrationsEndpoints from './integrations';
 import * as updatesEndpoints from './updates';
 import * as intercomEndpoints from './intercom';
+import * as googleMapsEndpoints from './googleMaps';
 
 type WashdayClientConstructor = {
     new(apiToken: string, env?: string, clientId?: string, clientSecret?: string): WashdayClientInstance
@@ -230,6 +231,16 @@ const WashdayClient: WashdayClientConstructor = function WashdayClient(this: Was
     this.config = bindMethods(this, {
         getTaxPresets: configEndpoints.getModule.getTaxPresets,
     });
+    this.googleMaps = bindMethods(this, {
+        autocompleteCustomersApp: googleMapsEndpoints.postModule.autocompleteCustomersApp,
+        placeDetailsCustomersApp: googleMapsEndpoints.postModule.placeDetailsCustomersApp,
+        geocodeCustomersApp: googleMapsEndpoints.postModule.geocodeCustomersApp,
+        reverseGeocodeCustomersApp: googleMapsEndpoints.postModule.reverseGeocodeCustomersApp,
+        autocomplete: googleMapsEndpoints.postModule.autocomplete,
+        placeDetails: googleMapsEndpoints.postModule.placeDetails,
+        geocode: googleMapsEndpoints.postModule.geocode,
+        reverseGeocode: googleMapsEndpoints.postModule.reverseGeocode,
+    });
     this.supplies = bindMethods(this, {
         getSupplies: getSupplies,
         getSupplyById: getSupplyById,

package/src/api/integrations/post.ts

@@ -1,11 +1,21 @@
 import { WashdayClientInstance } from "../../interfaces/Api";
+import { AppReturnUrlOptions } from "../../interfaces/DomainUrls";
 
 const BASE_ROUTER = 'api/integrations';
 const BASE_ROUTER_MP_ATTEMPTS = 'api/payments/mp/attempts';
 
-export const startMPOAuthFlow = async function (this: WashdayClientInstance, data: {
-    redirectUri: string;
-}): Promise<any> {
+export interface StartMPOAuthFlowRequest extends AppReturnUrlOptions {
+    /**
+     * @deprecated The backend owns the Mercado Pago OAuth callback now.
+     * Use returnToUrl or returnToOrigin/returnPath for the final app redirect.
+     */
+    redirectUri?: string;
+}
+
+export const startMPOAuthFlow = async function (
+    this: WashdayClientInstance,
+    data: StartMPOAuthFlowRequest
+): Promise<any> {
     try {
         const config = {
             headers: { Authorization: `Bearer ${this.apiToken}` }
@@ -119,4 +129,4 @@ export const cancelMPAttempt = async function (this: WashdayClientInstance, data
     catch (error) {
         throw error;
     }
-};
+};

package/src/api/stripe/post.ts

@@ -1,11 +1,25 @@
 import { WashdayClientInstance } from "../../interfaces/Api";
-import axiosInstance from "../axiosInstance";
+import { StripeReturnUrlOptions } from "../../interfaces/DomainUrls";
 const GET_SET_STRIPE = 'api/stripe';
 const GENERATE_CHECKOUT_SESSION = 'api/orders/create-checkout-session';
 
-export const createCreateSuscriptionCheckoutSession = async function (this: WashdayClientInstance, data: {
-    priceId: string
-}): Promise<any> {
+export interface CreateSubscriptionCheckoutSessionRequest extends StripeReturnUrlOptions {
+    priceId: string;
+    planKey?: string;
+}
+
+export interface CreateGetMoreCheckoutSessionRequest extends StripeReturnUrlOptions {
+    priceId: string;
+}
+
+export interface CreateCFDISubscriptionCheckoutSessionRequest extends StripeReturnUrlOptions {}
+
+export interface CreateCustomerPortalSessionRequest extends StripeReturnUrlOptions {}
+
+export const createCreateSuscriptionCheckoutSession = async function (
+    this: WashdayClientInstance,
+    data: CreateSubscriptionCheckoutSessionRequest
+): Promise<any> {
     try {
         const config = {
             headers: { Authorization: `Bearer ${this.apiToken}` }
@@ -18,7 +32,10 @@ export const createCreateSuscriptionCheckoutSession = async function (this: Wash
     }
 };
 
-export const createCustomerPortalSession = async function (this: WashdayClientInstance, data?: any): Promise<any> {
+export const createCustomerPortalSession = async function (
+    this: WashdayClientInstance,
+    data?: CreateCustomerPortalSessionRequest
+): Promise<any> {
     try {
         const config = {
             headers: { Authorization: `Bearer ${this.apiToken}` }
@@ -31,7 +48,10 @@ export const createCustomerPortalSession = async function (this: WashdayClientIn
     }
 };
 
-export const createCFDISuscrptionCheckoutSession = async function (this: WashdayClientInstance, data?: any): Promise<any> {
+export const createCFDISuscrptionCheckoutSession = async function (
+    this: WashdayClientInstance,
+    data?: CreateCFDISubscriptionCheckoutSessionRequest
+): Promise<any> {
     try {
         const config = {
             headers: { Authorization: `Bearer ${this.apiToken}` }
@@ -44,9 +64,10 @@ export const createCFDISuscrptionCheckoutSession = async function (this: Washday
     }
 };
 
-export const createGetMoreCheckoutSession = async function (this: WashdayClientInstance, data: {
-    priceId: string
-}): Promise<any> {
+export const createGetMoreCheckoutSession = async function (
+    this: WashdayClientInstance,
+    data: CreateGetMoreCheckoutSessionRequest
+): Promise<any> {
     try {
         const config = {
             headers: { Authorization: `Bearer ${this.apiToken}` }
@@ -56,4 +77,4 @@ export const createGetMoreCheckoutSession = async function (this: WashdayClientI
         console.error('Error fetching createGetMoreCheckoutSession:', error);
         throw error;
     }
-};
+};

package/src/index.ts

@@ -5,5 +5,14 @@ export * from './interfaces/Config';
 export * from './interfaces/Cfdi';
 export * from './interfaces/Auth';
 export * from './interfaces/Customer';
+export * from './interfaces/DomainUrls';
+export * from './interfaces/GoogleMaps';
+export type { StartMPOAuthFlowRequest } from './api/integrations/post';
+export type {
+  CreateCFDISubscriptionCheckoutSessionRequest,
+  CreateCustomerPortalSessionRequest,
+  CreateGetMoreCheckoutSessionRequest,
+  CreateSubscriptionCheckoutSessionRequest,
+} from './api/stripe/post';
 
 export { WashdayClient, utils };

package/src/interfaces/Api.ts

@@ -45,6 +45,7 @@ import * as publicsEndpoints from '../api/publics';
 import * as integrationsEndpoints from '../api/integrations';
 import * as updatesEndpoints from '../api/updates';
 import * as intercomEndpoints from '../api/intercom';
+import * as googleMapsEndpoints from '../api/googleMaps';
 import { validateUserPin } from "../api/users/post";
 import { AxiosInstance } from "axios";
 
@@ -215,6 +216,16 @@ export interface WashdayClientInstance {
     config: {
         getTaxPresets: typeof configEndpoints.getModule.getTaxPresets;
     };
+    googleMaps: {
+        autocompleteCustomersApp: typeof googleMapsEndpoints.postModule.autocompleteCustomersApp;
+        placeDetailsCustomersApp: typeof googleMapsEndpoints.postModule.placeDetailsCustomersApp;
+        geocodeCustomersApp: typeof googleMapsEndpoints.postModule.geocodeCustomersApp;
+        reverseGeocodeCustomersApp: typeof googleMapsEndpoints.postModule.reverseGeocodeCustomersApp;
+        autocomplete: typeof googleMapsEndpoints.postModule.autocomplete;
+        placeDetails: typeof googleMapsEndpoints.postModule.placeDetails;
+        geocode: typeof googleMapsEndpoints.postModule.geocode;
+        reverseGeocode: typeof googleMapsEndpoints.postModule.reverseGeocode;
+    };
     supplies: {
         getSupplies: typeof getSupplies;
         getSupplyById: typeof getSupplyById;

package/src/interfaces/DomainUrls.ts

@@ -0,0 +1,11 @@
+export interface AppReturnUrlOptions {
+  returnToUrl?: string;
+  returnToOrigin?: string;
+  returnPath?: string;
+  returnToPath?: string;
+}
+
+export interface StripeReturnUrlOptions {
+  returnToUrl?: string;
+  returnToOrigin?: string;
+}

package/src/interfaces/GoogleMaps.ts

@@ -0,0 +1,97 @@
+export interface GoogleMapsLatLng {
+  lat: number;
+  lng: number;
+}
+
+export interface GoogleMapsLocationBias {
+  circle: {
+    center: {
+      latitude: number;
+      longitude: number;
+    };
+    radius: number;
+  };
+}
+
+export interface GoogleMapsAutocompletePayload {
+  input: string;
+  sessionToken: string;
+  storeId?: string;
+  locationBias?: GoogleMapsLocationBias;
+  regionCode?: string;
+}
+
+export interface GoogleMapsPlaceDetailsPayload {
+  placeId?: string;
+  placeResourceName?: string;
+  sessionToken: string;
+  storeId?: string;
+}
+
+export interface GoogleMapsGeocodePayload {
+  address: string;
+  storeId?: string;
+  regionCode?: string;
+}
+
+export interface GoogleMapsReverseGeocodePayload {
+  latLng: GoogleMapsLatLng;
+  storeId?: string;
+}
+
+export interface GoogleMapsParsedAddressComponents {
+  street?: string;
+  number?: string;
+  neighborhood?: string;
+  postalCode?: string;
+  city?: string;
+  state?: string;
+  country?: string;
+}
+
+export interface GoogleMapsAutocompleteSuggestion {
+  placeId: string;
+  placeResourceName: string;
+  text: string;
+}
+
+export interface GoogleMapsPlaceDetailsResult {
+  placeId: string;
+  placeResourceName: string;
+  formattedAddress?: string;
+  latLng: GoogleMapsLatLng;
+  address: GoogleMapsParsedAddressComponents;
+}
+
+export interface GoogleMapsGeocodeResult {
+  placeId?: string;
+  formattedAddress?: string;
+  latLng: GoogleMapsLatLng;
+  address: GoogleMapsParsedAddressComponents;
+}
+
+export interface GoogleMapsAutocompleteResponse {
+  data: {
+    suggestions: GoogleMapsAutocompleteSuggestion[];
+  };
+  errors?: string[];
+}
+
+export interface GoogleMapsPlaceDetailsResponse {
+  data: GoogleMapsPlaceDetailsResult;
+  errors?: string[];
+}
+
+export interface GoogleMapsGeocodeResponse {
+  data: {
+    result: GoogleMapsGeocodeResult | null;
+  };
+  errors?: string[];
+}
+
+export interface GoogleMapsReverseGeocodeResponse {
+  data: {
+    result: GoogleMapsGeocodeResult | null;
+  };
+  errors?: string[];
+}

package/test/domainUrls.types.test.ts

@@ -0,0 +1,52 @@
+import { StartMPOAuthFlowRequest } from "../src/api/integrations/post";
+import {
+  CreateCFDISubscriptionCheckoutSessionRequest,
+  CreateCustomerPortalSessionRequest,
+  CreateGetMoreCheckoutSessionRequest,
+  CreateSubscriptionCheckoutSessionRequest,
+} from "../src/api/stripe/post";
+import { AppReturnUrlOptions } from "../src/interfaces/DomainUrls";
+
+describe("domain return URL request types", () => {
+  it("supports app and provider return URL options", () => {
+    const appReturnUrlOptions: AppReturnUrlOptions = {
+      returnToUrl: "https://app.washdaypos.com/settings/mercado-pago?storeId=store-1",
+      returnToOrigin: "https://app.washdaypos.com",
+      returnPath: "/settings/mercado-pago?storeId=store-1",
+    };
+
+    const mpRequest: StartMPOAuthFlowRequest = {
+      returnToUrl: "https://app.washdaypos.com/settings/mercado-pago?storeId=store-1",
+    };
+
+    const legacyMpRequest: StartMPOAuthFlowRequest = {
+      redirectUri: "https://app.washday.mx/integrations/mercadopago/callback",
+    };
+
+    const subscriptionRequest: CreateSubscriptionCheckoutSessionRequest = {
+      priceId: "price_1",
+      returnToOrigin: "https://app.washdaypos.com",
+    };
+
+    const extraOrdersRequest: CreateGetMoreCheckoutSessionRequest = {
+      priceId: "price_extra",
+      returnToOrigin: "https://app.washday.mx",
+    };
+
+    const cfdiRequest: CreateCFDISubscriptionCheckoutSessionRequest = {
+      returnToUrl: "https://app.washdaypos.com/settings/company-info",
+    };
+
+    const portalRequest: CreateCustomerPortalSessionRequest = {
+      returnToUrl: "https://app.washdaypos.com/settings",
+    };
+
+    expect(appReturnUrlOptions.returnToOrigin).toBe("https://app.washdaypos.com");
+    expect(mpRequest.returnToUrl).toBe("https://app.washdaypos.com/settings/mercado-pago?storeId=store-1");
+    expect(legacyMpRequest.redirectUri).toBe("https://app.washday.mx/integrations/mercadopago/callback");
+    expect(subscriptionRequest.returnToOrigin).toBe("https://app.washdaypos.com");
+    expect(extraOrdersRequest.returnToOrigin).toBe("https://app.washday.mx");
+    expect(cfdiRequest.returnToUrl).toBe("https://app.washdaypos.com/settings/company-info");
+    expect(portalRequest.returnToUrl).toBe("https://app.washdaypos.com/settings");
+  });
+});

package/test/googleMaps.proxyEndpoints.test.ts

@@ -0,0 +1,154 @@
+import WashdayClient from "../src/api";
+import {
+  autocomplete,
+  autocompleteCustomersApp,
+  geocode,
+  geocodeCustomersApp,
+  placeDetails,
+  placeDetailsCustomersApp,
+  reverseGeocode,
+  reverseGeocodeCustomersApp,
+} from "../src/api/googleMaps/post";
+import {
+  GoogleMapsAutocompletePayload,
+  GoogleMapsGeocodePayload,
+  GoogleMapsPlaceDetailsPayload,
+  GoogleMapsReverseGeocodePayload,
+} from "../src/interfaces/GoogleMaps";
+
+const autocompletePayload: GoogleMapsAutocompletePayload = {
+  input: "Calle 60",
+  sessionToken: "session-123",
+  storeId: "store-123",
+  regionCode: "MX",
+  locationBias: {
+    circle: {
+      center: { latitude: 20.97, longitude: -89.62 },
+      radius: 12000,
+    },
+  },
+};
+
+const placeDetailsPayload: GoogleMapsPlaceDetailsPayload = {
+  placeResourceName: "places/abc",
+  sessionToken: "session-123",
+  storeId: "store-123",
+};
+
+const geocodePayload: GoogleMapsGeocodePayload = {
+  address: "Calle 60, Merida",
+  storeId: "store-123",
+  regionCode: "MX",
+};
+
+const reverseGeocodePayload: GoogleMapsReverseGeocodePayload = {
+  latLng: { lat: 20.97, lng: -89.62 },
+  storeId: "store-123",
+};
+
+function createClient() {
+  return {
+    apiToken: "token-123",
+    axiosInstance: {
+      post: jest.fn().mockResolvedValue({ data: { data: {} } }),
+    },
+  } as any;
+}
+
+describe("google maps proxy endpoints", () => {
+  it("calls Customers App Google Maps proxy endpoints with customer token", async () => {
+    const client = createClient();
+
+    await autocompleteCustomersApp.call(client, autocompletePayload);
+    await placeDetailsCustomersApp.call(client, placeDetailsPayload);
+    await geocodeCustomersApp.call(client, geocodePayload);
+    await reverseGeocodeCustomersApp.call(client, reverseGeocodePayload);
+
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      1,
+      "api/v2/washdayapp/google-maps/autocomplete",
+      autocompletePayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      2,
+      "api/v2/washdayapp/google-maps/place-details",
+      placeDetailsPayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      3,
+      "api/v2/washdayapp/google-maps/geocode",
+      geocodePayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      4,
+      "api/v2/washdayapp/google-maps/reverse-geocode",
+      reverseGeocodePayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+  });
+
+  it("calls internal user Google Maps proxy endpoints with user token", async () => {
+    const client = createClient();
+
+    await autocomplete.call(client, autocompletePayload);
+    await placeDetails.call(client, placeDetailsPayload);
+    await geocode.call(client, geocodePayload);
+    await reverseGeocode.call(client, reverseGeocodePayload);
+
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      1,
+      "api/v2/google-maps/autocomplete",
+      autocompletePayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      2,
+      "api/v2/google-maps/place-details",
+      placeDetailsPayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      3,
+      "api/v2/google-maps/geocode",
+      geocodePayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      4,
+      "api/v2/google-maps/reverse-geocode",
+      reverseGeocodePayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+  });
+
+  it("exposes Google Maps proxy methods through wdClient.googleMaps", async () => {
+    const client = new (WashdayClient as any)("token-123", "DEV");
+    client.axiosInstance.post = jest.fn().mockResolvedValue({ data: { data: {} } });
+
+    await client.googleMaps.autocompleteCustomersApp(autocompletePayload);
+    await client.googleMaps.placeDetailsCustomersApp(placeDetailsPayload);
+    await client.googleMaps.geocodeCustomersApp(geocodePayload);
+    await client.googleMaps.reverseGeocodeCustomersApp(reverseGeocodePayload);
+    await client.googleMaps.autocomplete(autocompletePayload);
+    await client.googleMaps.placeDetails(placeDetailsPayload);
+    await client.googleMaps.geocode(geocodePayload);
+    await client.googleMaps.reverseGeocode(reverseGeocodePayload);
+
+    expect(client.axiosInstance.post).toHaveBeenCalledTimes(8);
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      1,
+      "api/v2/washdayapp/google-maps/autocomplete",
+      autocompletePayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+    expect(client.axiosInstance.post).toHaveBeenNthCalledWith(
+      8,
+      "api/v2/google-maps/reverse-geocode",
+      reverseGeocodePayload,
+      { headers: { Authorization: "Bearer token-123" } }
+    );
+  });
+});

package/test/integrations.domainReturnUrls.test.ts

@@ -0,0 +1,25 @@
+import { startMPOAuthFlow } from "../src/api/integrations/post";
+
+describe("startMPOAuthFlow return URL options", () => {
+  it("posts returnToUrl without requiring callers to provide the OAuth callback redirectUri", async () => {
+    const post = jest.fn().mockResolvedValue({ data: { data: { authUrl: "https://mp.example/auth" } } });
+    const client = {
+      apiToken: "token-1",
+      axiosInstance: { post },
+    } as any;
+
+    await startMPOAuthFlow.call(client, {
+      returnToUrl: "https://app.washdaypos.com/settings/mercado-pago?storeId=store-1",
+    });
+
+    expect(post).toHaveBeenCalledWith(
+      "api/integrations/mp/oauth/start",
+      {
+        returnToUrl: "https://app.washdaypos.com/settings/mercado-pago?storeId=store-1",
+      },
+      {
+        headers: { Authorization: "Bearer token-1" },
+      },
+    );
+  });
+});

package/test/stripe.domainReturnUrls.test.ts

@@ -0,0 +1,92 @@
+import {
+  createCFDISuscrptionCheckoutSession,
+  createCreateSuscriptionCheckoutSession,
+  createCustomerPortalSession,
+  createGetMoreCheckoutSession,
+} from "../src/api/stripe/post";
+
+describe("stripe checkout return URL options", () => {
+  it("passes returnToOrigin for subscription checkout", async () => {
+    const post = jest.fn().mockResolvedValue({ data: { data: { url: "https://stripe.example" } } });
+    const client = {
+      apiToken: "token-1",
+      axiosInstance: { post },
+    } as any;
+
+    await createCreateSuscriptionCheckoutSession.call(client, {
+      priceId: "price_1",
+      returnToOrigin: "https://app.washdaypos.com",
+    });
+
+    expect(post).toHaveBeenCalledWith(
+      "api/stripe/create-subscription-checkout-session",
+      {
+        priceId: "price_1",
+        returnToOrigin: "https://app.washdaypos.com",
+      },
+      {
+        headers: { Authorization: "Bearer token-1" },
+      },
+    );
+  });
+
+  it("passes returnToOrigin for extra orders checkout", async () => {
+    const post = jest.fn().mockResolvedValue({ data: { data: { url: "https://stripe.example" } } });
+    const client = {
+      apiToken: "token-1",
+      axiosInstance: { post },
+    } as any;
+
+    await createGetMoreCheckoutSession.call(client, {
+      priceId: "price_extra",
+      returnToOrigin: "https://app.washday.mx",
+    });
+
+    expect(post).toHaveBeenCalledWith(
+      "api/orders/create-checkout-session",
+      {
+        priceId: "price_extra",
+        returnToOrigin: "https://app.washday.mx",
+      },
+      {
+        headers: { Authorization: "Bearer token-1" },
+      },
+    );
+  });
+
+  it("passes returnToUrl for CFDI checkout and customer portal", async () => {
+    const post = jest.fn().mockResolvedValue({ data: { data: { url: "https://stripe.example" } } });
+    const client = {
+      apiToken: "token-1",
+      axiosInstance: { post },
+    } as any;
+
+    await createCFDISuscrptionCheckoutSession.call(client, {
+      returnToUrl: "https://app.washdaypos.com/settings/company-info",
+    });
+    await createCustomerPortalSession.call(client, {
+      returnToUrl: "https://app.washdaypos.com/settings",
+    });
+
+    expect(post).toHaveBeenNthCalledWith(
+      1,
+      "api/stripe/create-cfdi-subscription-checkout-session",
+      {
+        returnToUrl: "https://app.washdaypos.com/settings/company-info",
+      },
+      {
+        headers: { Authorization: "Bearer token-1" },
+      },
+    );
+    expect(post).toHaveBeenNthCalledWith(
+      2,
+      "api/stripe/create-customer-portal-session",
+      {
+        returnToUrl: "https://app.washdaypos.com/settings",
+      },
+      {
+        headers: { Authorization: "Bearer token-1" },
+      },
+    );
+  });
+});