@parseapi/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,174 @@
+// src/index.ts
+var VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://api.parseapi.com";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_RETRIES = 2;
+var RETRY_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var RETRY_AFTER_CAP_MS = 5e3;
+var ParseAPIError = class extends Error {
+  /** HTTP status */
+  status;
+  /** Machine-readable error code, e.g. 'not_found', 'invalid_api_key', 'rate_limited' */
+  code;
+  /** Link to the docs section for this error */
+  docs;
+  /** Send this if you contact support */
+  requestId;
+  constructor(status, code, message, docs, requestId) {
+    super(message);
+    this.name = "ParseAPIError";
+    this.status = status;
+    this.code = code;
+    this.docs = docs;
+    this.requestId = requestId;
+  }
+};
+function env(name) {
+  return typeof process !== "undefined" ? process.env?.[name] : void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retryDelayMs(attempt, retryAfter) {
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1e3, RETRY_AFTER_CAP_MS);
+    }
+  }
+  return Math.random() * 250 * 2 ** attempt;
+}
+function parseAPI(apiKey, options = {}) {
+  const key = apiKey ?? env("PARSEAPI_KEY");
+  if (!key) {
+    throw new Error("parseAPI: missing API key. Pass one or set PARSEAPI_KEY.");
+  }
+  const baseUrl = (options.baseUrl ?? env("PARSEAPI_BASE_URL") ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const retries = options.retries ?? DEFAULT_RETRIES;
+  const doFetch = options.fetch ?? fetch;
+  async function request(path, query, headers) {
+    const url = new URL(baseUrl + path);
+    for (const [name, value] of Object.entries(query ?? {})) {
+      if (value !== void 0) url.searchParams.set(name, String(value));
+    }
+    for (let attempt = 0; ; attempt++) {
+      let res;
+      try {
+        res = await doFetch(url, {
+          headers: {
+            "X-API-Key": key,
+            "User-Agent": `parseapi-node/${VERSION}`,
+            ...headers
+          },
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+      } catch (err) {
+        if (attempt < retries) {
+          await sleep(retryDelayMs(attempt, null));
+          continue;
+        }
+        throw err;
+      }
+      if (res.ok) {
+        return await res.json();
+      }
+      if (RETRY_STATUS.has(res.status) && attempt < retries) {
+        await sleep(retryDelayMs(attempt, res.headers.get("Retry-After")));
+        continue;
+      }
+      let body = {};
+      try {
+        body = await res.json();
+      } catch {
+      }
+      throw new ParseAPIError(
+        res.status,
+        typeof body.code === "string" ? body.code : "unknown_error",
+        typeof body.message === "string" ? body.message : `Request failed with status ${res.status}`,
+        typeof body.docs === "string" ? body.docs : null,
+        typeof body.request_id === "string" ? body.request_id : null
+      );
+    }
+  }
+  const enc = encodeURIComponent;
+  const deepQuery = (opts) => opts?.deep ? { deep: true } : {};
+  return {
+    ip: Object.assign(
+      (ip, opts) => request(`/ip/${enc(ip)}`, deepQuery(opts)),
+      {
+        self: (opts) => request("/ip", deepQuery(opts))
+      }
+    ),
+    continent: Object.assign(
+      (code) => request(`/continent/${enc(code)}`),
+      {
+        countries: (code) => request(`/continent/${enc(code)}/countries`)
+      }
+    ),
+    country: Object.assign(
+      (code) => request(`/country/${enc(code)}`),
+      {
+        states: (code) => request(`/country/${enc(code)}/states`)
+      }
+    ),
+    state: Object.assign(
+      (code, opts) => request(`/state/${enc(code)}`, { country: opts.country }),
+      {
+        districts: (code, opts) => request(`/state/${enc(code)}/districts`, { country: opts.country })
+      }
+    ),
+    district: (code, opts) => request(`/district/${enc(code)}`, { country: opts?.country }),
+    city: Object.assign(
+      (name, opts) => request(`/city/${enc(name)}`, { country: opts?.country, state: opts?.state }),
+      {
+        id: (id) => request(`/city/id/${enc(id)}`),
+        search: (q, opts) => request("/city", { q, country: opts?.country, state: opts?.state, limit: opts?.limit }),
+        nearest: (lat, lon) => request("/city", { lat, lon })
+      }
+    ),
+    postal: Object.assign(
+      (code, opts) => request(`/postal/${enc(code)}`, { country: opts.country }),
+      {
+        nearby: (code, opts) => request(`/postal/${enc(code)}/nearby`, {
+          country: opts.country,
+          radius: opts.radius,
+          unit: opts.unit
+        }),
+        distance: (from, to, opts) => request(`/postal/${enc(from)}/distance/${enc(to)}`, { country: opts.country })
+      }
+    ),
+    email: (email, opts) => request(`/email/${enc(email)}`, deepQuery(opts)),
+    phone: (number, opts) => request(`/phone/${enc(number)}`, { country: opts?.country, ...deepQuery(opts) }),
+    domain: (domain, opts) => request(`/domain/${enc(domain)}`, deepQuery(opts)),
+    mx: (domain) => request(`/mx/${enc(domain)}`),
+    useragent: (ua, opts) => request("/useragent", deepQuery(opts), { "User-Agent": ua }),
+    currency: Object.assign(
+      (code) => request(`/currency/${enc(code)}`),
+      {
+        rate: (base, quote) => request(`/currency/${enc(base)}/${enc(quote)}`)
+      }
+    ),
+    language: (code) => request(`/language/${enc(code)}`),
+    timezone: (id, opts) => request(`/timezone/${enc(id)}`, { at: opts?.at }),
+    holiday: Object.assign(
+      (country, opts) => request(`/holiday/${enc(country)}`, { year: opts?.year }),
+      {
+        date: (country, date) => request(`/holiday/${enc(country)}/${enc(date)}`)
+      }
+    ),
+    elevation: (lat, lon) => request("/elevation", { lat, lon }),
+    point: (lat, lon, opts) => request("/point", { lat, lon, ...deepQuery(opts) }),
+    weather: (lat, lon, opts) => request("/weather", { lat, lon, ...deepQuery(opts) }),
+    emoji: Object.assign(
+      (emoji) => request(`/emoji/${enc(emoji)}`),
+      {
+        search: (q, opts) => request("/emoji", { q, limit: opts?.limit })
+      }
+    )
+  };
+}
+export {
+  ParseAPIError,
+  parseAPI
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "@parseapi/sdk",
+	"version": "0.1.0",
+	"description": "Official parseAPI client for Node and TypeScript. One key, minimal JSON, fast.",
+	"keywords": [
+		"parseapi",
+		"ip",
+		"geolocation",
+		"email validation",
+		"phone validation",
+		"postal",
+		"timezone",
+		"currency",
+		"weather"
+	],
+	"license": "MIT",
+	"author": "parseAPI <hello@parseapi.com> (https://parseapi.com)",
+	"homepage": "https://parseapi.com",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/parseapi/parseapi-node.git"
+	},
+	"bugs": {
+		"url": "https://github.com/parseapi/parseapi-node/issues"
+	},
+	"type": "module",
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"sideEffects": false,
+	"engines": {
+		"node": ">=18"
+	},
+	"scripts": {
+		"build": "tsup src/index.ts --format esm,cjs --dts --target node18 --clean",
+		"prepublishOnly": "npm run build && npm test",
+		"test": "vitest run",
+		"typecheck": "tsc --noEmit",
+		"smoke": "npm run build && node smoke/smoke.mjs"
+	},
+	"devDependencies": {
+		"@types/node": "^22.10.0",
+		"tsup": "^8.3.5",
+		"typescript": "^5.7.0",
+		"vitest": "^2.1.8"
+	}
+}