apple-maps-server-sdk 1.0.0 → 1.0.2

package/lib/index.d.ts

@@ -1 +1,15 @@
-export declare const Greeter: (name: string) => string;
+import { AxiosInstance } from "axios";
+declare class AppleMaps {
+    accessToken: string;
+    authorizationToken: string;
+    apiClient: AxiosInstance;
+    constructor({ authorizationToken }: {
+        authorizationToken: string;
+    });
+    getAccessToken(): Promise<undefined>;
+    geocode(input: GeocodeInput): Promise<GeocodeResponse>;
+    reverseGeocode(input: ReverseGeocodeInput): Promise<ReverseGeocodeResponse>;
+    eta(input: ETAInput): Promise<ETAResponse>;
+    search(input: SearchInput): Promise<SearchResponse>;
+}
+export default AppleMaps;

package/lib/index.js

@@ -1,5 +1,180 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Greeter = void 0;
-var Greeter = function (name) { return "Hello ".concat(name); };
-exports.Greeter = Greeter;
+const axios_1 = __importStar(require("axios"));
+const qs_1 = __importDefault(require("qs"));
+class AppleMaps {
+    constructor({ authorizationToken }) {
+        this.accessToken = "";
+        this.authorizationToken = authorizationToken;
+        if (!authorizationToken) {
+            throw new Error("'authorizationToken' param is required");
+        }
+        this.apiClient = axios_1.default.create({
+            baseURL: "https://maps-api.apple.com/v1",
+        });
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.apiClient.get("/token", {
+                    headers: {
+                        Authorization: `Bearer ${this.authorizationToken}`,
+                    },
+                });
+                this.accessToken = response.data.accessToken;
+            }
+            catch (error) {
+                console.error(error);
+            }
+            return;
+        });
+    }
+    geocode(input) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = qs_1.default.stringify(input);
+            try {
+                const response = yield this.apiClient.get("/geocode", {
+                    headers: {
+                        Authorization: `Bearer ${this.accessToken}`,
+                    },
+                    params,
+                });
+                return response.data;
+            }
+            catch (error) {
+                if (error instanceof axios_1.AxiosError) {
+                    if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                        yield this.getAccessToken();
+                        return this.geocode(input);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else
+                    throw error;
+            }
+        });
+    }
+    reverseGeocode(input) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = qs_1.default.stringify(input);
+            try {
+                const response = yield this.apiClient.get("/reverseGeocode", {
+                    headers: {
+                        Authorization: `Bearer ${this.accessToken}`,
+                    },
+                    params,
+                });
+                return response.data;
+            }
+            catch (error) {
+                if (error instanceof axios_1.AxiosError) {
+                    if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                        yield this.getAccessToken();
+                        return this.reverseGeocode(input);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else
+                    throw error;
+            }
+        });
+    }
+    eta(input) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = qs_1.default.stringify(input);
+            try {
+                const response = yield this.apiClient.get("/etas", {
+                    headers: {
+                        Authorization: `Bearer ${this.accessToken}`,
+                    },
+                    params,
+                });
+                return response.data;
+            }
+            catch (error) {
+                if (error instanceof axios_1.AxiosError) {
+                    if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                        yield this.getAccessToken();
+                        return this.eta(input);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else
+                    throw error;
+            }
+        });
+    }
+    search(input) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = qs_1.default.stringify(input);
+            try {
+                const response = yield this.apiClient.get("/search", {
+                    headers: {
+                        Authorization: `Bearer ${this.accessToken}`,
+                    },
+                    params,
+                });
+                return response.data;
+            }
+            catch (error) {
+                if (error instanceof axios_1.AxiosError) {
+                    if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                        yield this.getAccessToken();
+                        return this.search(input);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else
+                    throw error;
+            }
+        });
+    }
+}
+exports.default = AppleMaps;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apple-maps-server-sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "An SDK for the Apple Maps Server API",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -21,6 +21,11 @@
   },
   "homepage": "https://github.com/JS00001/apple-maps-server-sdk#readme",
   "devDependencies": {
+    "@types/qs": "^6.9.7",
     "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "axios": "^1.2.2",
+    "qs": "^6.11.0"
   }
 }

package/src/index.ts

@@ -1 +1,135 @@
-export const Greeter = (name: string) => `Hello ${name}`;
+import axios, { AxiosError, AxiosInstance } from "axios";
+import qs from "qs";
+
+class AppleMaps {
+  accessToken: string;
+  authorizationToken: string;
+  apiClient: AxiosInstance;
+
+  constructor({ authorizationToken }: { authorizationToken: string }) {
+    this.accessToken = "";
+    this.authorizationToken = authorizationToken;
+
+    if (!authorizationToken) {
+      throw new Error("'authorizationToken' param is required");
+    }
+
+    this.apiClient = axios.create({
+      baseURL: "https://maps-api.apple.com/v1",
+    });
+  }
+
+  async getAccessToken(): Promise<undefined> {
+    try {
+      const response = await this.apiClient.get("/token", {
+        headers: {
+          Authorization: `Bearer ${this.authorizationToken}`,
+        },
+      });
+
+      this.accessToken = response.data.accessToken;
+    } catch (error) {
+      console.error(error);
+    }
+
+    return;
+  }
+
+  async geocode(input: GeocodeInput): Promise<GeocodeResponse> {
+    const params = qs.stringify(input);
+
+    try {
+      const response = await this.apiClient.get("/geocode", {
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+        },
+        params,
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        if (error.response?.status === 401) {
+          await this.getAccessToken();
+          return this.geocode(input);
+        } else {
+          throw error;
+        }
+      } else throw error;
+    }
+  }
+
+  async reverseGeocode(input: ReverseGeocodeInput): Promise<ReverseGeocodeResponse> {
+    const params = qs.stringify(input);
+
+    try {
+      const response = await this.apiClient.get("/reverseGeocode", {
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+        },
+        params,
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        if (error.response?.status === 401) {
+          await this.getAccessToken();
+          return this.reverseGeocode(input);
+        } else {
+          throw error;
+        }
+      } else throw error;
+    }
+  }
+
+  async eta(input: ETAInput): Promise<ETAResponse> {
+    const params = qs.stringify(input);
+
+    try {
+      const response = await this.apiClient.get("/etas", {
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+        },
+        params,
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        if (error.response?.status === 401) {
+          await this.getAccessToken();
+          return this.eta(input);
+        } else {
+          throw error;
+        }
+      } else throw error;
+    }
+  }
+
+  async search(input: SearchInput): Promise<SearchResponse> {
+    const params = qs.stringify(input);
+
+    try {
+      const response = await this.apiClient.get("/search", {
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+        },
+        params,
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        if (error.response?.status === 401) {
+          await this.getAccessToken();
+          return this.search(input);
+        } else {
+          throw error;
+        }
+      } else throw error;
+    }
+  }
+}
+
+export default AppleMaps;

package/src/inputs.d.ts

@@ -0,0 +1,33 @@
+interface GeocodeInput {
+  q: string;
+  limitToCountries?: string[];
+  lang?: string;
+  searchLocation?: string;
+  searchRegion?: string;
+  userLocation?: string;
+}
+
+interface ReverseGeocodeInput {
+  q: string;
+  lang?: string;
+}
+
+interface ETAInput {
+  origin: string;
+  destinations: string[];
+  transportType?: TransportType;
+  departureDate?: string;
+  arrivalDate?: string;
+}
+
+interface SearchInput {
+  q: string;
+  excludePoiCategories?: PoiCategory[];
+  includePoiCategories?: PoiCategory[];
+  limitToCountries?: string[];
+  resultTypeFilter?: "Poi" | "Address";
+  lang?: string;
+  searchLocation?: string;
+  searchRegion?: string;
+  userLocation?: string;
+}

package/src/responses.d.ts

@@ -0,0 +1,16 @@
+interface GeocodeResponse {
+  response: Place[];
+}
+
+interface ReverseGeocodeResponse {
+  response: Place[];
+}
+
+interface ETAResponse {
+  etas: ETA[];
+}
+
+interface SearchResponse {
+  displayMapRegion: MapRegion;
+  results: SearchResponsePlace[];
+}

package/src/types.d.ts

@@ -0,0 +1,95 @@
+// OBJECTS
+type PoiCategory =
+  | "Airport"
+  | "AirportGate"
+  | "AirportTerminal"
+  | "AmusementPark"
+  | "ATM"
+  | "Aquarium"
+  | "Bakery"
+  | "Bank"
+  | "Beach"
+  | "Brewery"
+  | "Cafe"
+  | "Campground"
+  | "CarRental"
+  | "EVCharger"
+  | "FireStation"
+  | "FitnessCenter"
+  | "FoodMarket"
+  | "GasStation"
+  | "Hospital"
+  | "Hotel"
+  | "Laundry"
+  | "Library"
+  | "Marina"
+  | "MovieTheater"
+  | "Museum"
+  | "NationalPark"
+  | "Nightlife"
+  | "Park"
+  | "Parking"
+  | "Pharmacy"
+  | "Playground"
+  | "Police"
+  | "PostOffice"
+  | "PublicTransport"
+  | "ReligiousSite"
+  | "Restaurant"
+  | "Restroom"
+  | "School"
+  | "Stadium"
+  | "Store"
+  | "Theater"
+  | "University"
+  | "Winery"
+  | "Zoo";
+
+type TransportType = "Automobile" | "Transit" | "Walking";
+
+interface Location {
+  latitude: number;
+  longitude: number;
+}
+
+interface MapRegion {
+  eastLongitude: number;
+  northLatitude: number;
+  southLatitude: number;
+  westLongitude: number;
+}
+
+interface StructuredAddress {
+  administrativeArea: string;
+  administrativeAreaCode: string;
+  areasOfInterest: string[];
+  dependentLocalities: string[];
+  fullThoroughfare: string;
+  locality: string;
+  postCode: string;
+  subLocality: string;
+  subThoroughfare: string;
+  thoroughfare: string;
+}
+
+interface Place {
+  country: string;
+  countryCode: string;
+  displayMapRegion: MapRegion;
+  formattedAddressLines: string[];
+  name: string;
+  coordinate: Location;
+  structuredAddress: StructuredAddress;
+}
+
+interface ETA {
+  destination: Location;
+  distanceMeters: number;
+  expectedTravelTimeSeconds: number;
+  staticTravelTimeSeconds: number;
+  transportType: TransportType;
+}
+
+interface SearchResponsePlace extends Place {
+  poiCategory: PoiCategory;
+}

package/tsconfig.json

@@ -1,10 +1,12 @@
 {
   "compilerOptions": {
-    "target": "es5",
+    "target": "ES6",
     "module": "commonjs",
     "declaration": true,
     "outDir": "./lib",
-    "strict": true
+    "strict": true,
+    "esModuleInterop": true,
+    
   },
   "include": ["src"],
   "exclude": ["node_modules", "**/__tests__/*"]