@swapkit/api-sdk-typescript 1.0.0 → 1.0.5

package/dist/index.js

@@ -13,7 +13,7 @@ var extraPrefixesMap = {
 var extraPrefixes = Object.entries(extraPrefixesMap);
 
 // src/core/serverSentEvents.ts
-var createSseClient = ({
+function createSseClient({
   onRequest,
   onSseError,
   onSseEvent,
@@ -25,7 +25,7 @@ var createSseClient = ({
   sseSleepFn,
   url,
   ...options
-}) => {
+}) {
   let lastEventId;
   const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const createStream = async function* () {
@@ -69,7 +69,7 @@ var createSseClient = ({
             const { done, value } = await reader.read();
             if (done) break;
             buffer += value;
-            buffer = buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+            buffer = buffer.replace(/\r\n?/g, "\n");
             const chunks = buffer.split("\n\n");
             buffer = chunks.pop() ?? "";
             for (const chunk of chunks) {
@@ -137,7 +137,7 @@ var createSseClient = ({
   };
   const stream = createStream();
   return { stream };
-};
+}
 
 // src/core/pathSerializer.ts
 var separatorArrayExplode = (style) => {
@@ -625,8 +625,9 @@ var createClient = (config = {}) => {
     if (opts.body === void 0 || opts.serializedBody === "") {
       opts.headers.delete("Content-Type");
     }
-    const url = buildUrl(opts);
-    return { opts, url };
+    const resolvedOpts = opts;
+    const url = buildUrl(resolvedOpts);
+    return { opts: resolvedOpts, url };
   };
   const request = async (options) => {
     const { opts, url } = await beforeRequest(options);
@@ -772,8 +773,9 @@ var createClient = (config = {}) => {
       url
     });
   };
+  const _buildUrl = (options) => buildUrl({ ..._config, ...options });
   return {
-    buildUrl,
+    buildUrl: _buildUrl,
     connect: makeMethodFn("CONNECT"),
     delete: makeMethodFn("DELETE"),
     get: makeMethodFn("GET"),
@@ -802,7 +804,7 @@ var createClient = (config = {}) => {
 };
 
 // src/client.ts
-var client = createClient(createConfig({ baseUrl: "http://localhost:8080" }));
+var client = createClient(createConfig({ baseUrl: "http://localhost:0" }));
 
 // src/config.ts
 function configureSwapKit(options) {
@@ -824,17 +826,17 @@ var getTokens = (options) => (options?.client ?? client).get({
   url: "/tokens",
   ...options
 });
-var getSwapTo = (options) => (options.client ?? client).get({
+var getSwapToAssets = (options) => (options.client ?? client).get({
   security: [{ name: "x-api-key", type: "apiKey" }],
   url: "/swapTo",
   ...options
 });
-var getSwapFrom = (options) => (options.client ?? client).get({
+var getSwapFromAssets = (options) => (options.client ?? client).get({
   security: [{ name: "x-api-key", type: "apiKey" }],
   url: "/swapFrom",
   ...options
 });
-var postChainflipBrokerChannel = (options) => (options.client ?? client).post({
+var createBrokerChannel = (options) => (options.client ?? client).post({
   security: [{ name: "x-api-key", type: "apiKey" }],
   url: "/chainflip/broker/channel",
   ...options,
@@ -843,7 +845,7 @@ var postChainflipBrokerChannel = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
-var postTrack = (options) => (options?.client ?? client).post({
+var trackTransaction = (options) => (options?.client ?? client).post({
   security: [{ name: "x-api-key", type: "apiKey" }],
   url: "/track",
   ...options,
@@ -852,7 +854,7 @@ var postTrack = (options) => (options?.client ?? client).post({
     ...options?.headers
   }
 });
-var postScreen = (options) => (options.client ?? client).post({
+var screenAddress = (options) => (options.client ?? client).post({
   security: [{ name: "x-api-key", type: "apiKey" }],
   url: "/screen",
   ...options,
@@ -861,17 +863,17 @@ var postScreen = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
-var getGasHistory = (options) => (options?.client ?? client).get({
+var getGasPrices = (options) => (options?.client ?? client).get({
   security: [{ name: "x-api-key", type: "apiKey" }],
-  url: "/gas/history",
+  url: "/gas",
   ...options
 });
-var getGas = (options) => (options?.client ?? client).get({
+var getGasHistory = (options) => (options?.client ?? client).get({
   security: [{ name: "x-api-key", type: "apiKey" }],
-  url: "/gas",
+  url: "/gas/history",
   ...options
 });
-var postPriceCachedPrice = (options) => (options.client ?? client).post({
+var getCachedPrice = (options) => (options.client ?? client).post({
   security: [{ name: "x-api-key", type: "apiKey" }],
   url: "/price/cached-price",
   ...options,
@@ -880,7 +882,7 @@ var postPriceCachedPrice = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
-var postV3Quote = (options) => (options.client ?? client).post({
+var getQuote = (options) => (options.client ?? client).post({
   security: [{ name: "x-api-key", type: "apiKey" }],
   url: "/v3/quote",
   ...options,
@@ -889,7 +891,7 @@ var postV3Quote = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
-var postV3Swap = (options) => (options.client ?? client).post({
+var executeSwap = (options) => (options.client ?? client).post({
   security: [{ name: "x-api-key", type: "apiKey" }],
   url: "/v3/swap",
   ...options,
@@ -904,43 +906,43 @@ var SwapKitService = class {
 };
 SwapKitService.getProviders = getProviders;
 SwapKitService.getTokens = getTokens;
-SwapKitService.getSwapTo = getSwapTo;
-SwapKitService.getSwapFrom = getSwapFrom;
-SwapKitService.getQuote = postV3Quote;
-SwapKitService.getSwap = postV3Swap;
-SwapKitService.trackTransaction = postTrack;
-SwapKitService.screenAddress = postScreen;
-SwapKitService.getGasPrices = getGas;
+SwapKitService.getSwapTo = getSwapToAssets;
+SwapKitService.getSwapFrom = getSwapFromAssets;
+SwapKitService.getQuote = getQuote;
+SwapKitService.getSwap = executeSwap;
+SwapKitService.trackTransaction = trackTransaction;
+SwapKitService.screenAddress = screenAddress;
+SwapKitService.getGasPrices = getGasPrices;
 SwapKitService.getGasHistory = getGasHistory;
-SwapKitService.getCachedPrice = postPriceCachedPrice;
-SwapKitService.createBrokerChannel = postChainflipBrokerChannel;
+SwapKitService.getCachedPrice = getCachedPrice;
+SwapKitService.createBrokerChannel = createBrokerChannel;
 var TokenlistService = {
   getProviders,
   getTokens,
-  getSwapTo,
-  getSwapFrom
+  getSwapTo: getSwapToAssets,
+  getSwapFrom: getSwapFromAssets
 };
 var QuoteService = {
-  getQuote: postV3Quote
+  getQuote
 };
 var SwapService = {
-  getSwap: postV3Swap
+  getSwap: executeSwap
 };
 var TrackService = {
-  trackTransaction: postTrack
+  trackTransaction
 };
 var ScreenService = {
-  screenAddress: postScreen
+  screenAddress
 };
 var GasService = {
-  getGasPrices: getGas,
+  getGasPrices,
   getGasHistory
 };
 var PriceService = {
-  getCachedPrice: postPriceCachedPrice
+  getCachedPrice
 };
 var ChainflipService = {
-  createBrokerChannel: postChainflipBrokerChannel
+  createBrokerChannel
 };
 export {
   ChainflipService,
@@ -954,16 +956,16 @@ export {
   TrackService,
   client,
   configureSwapKit,
-  getGas,
+  createBrokerChannel,
+  executeSwap,
+  getCachedPrice,
   getGasHistory,
+  getGasPrices,
   getProviders,
-  getSwapFrom,
-  getSwapTo,
+  getQuote,
+  getSwapFromAssets,
+  getSwapToAssets,
   getTokens,
-  postChainflipBrokerChannel,
-  postPriceCachedPrice,
-  postScreen,
-  postTrack,
-  postV3Quote,
-  postV3Swap
+  screenAddress,
+  trackTransaction
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swapkit/api-sdk-typescript",
-  "version": "1.0.0",
+  "version": "1.0.5",
   "description": "Type-safe TypeScript SDK for the SwapKit API",
   "license": "MIT",
   "type": "module",
@@ -12,16 +12,16 @@
     }
   },
   "files": [
-    "dist/"
+    "dist/",
+    "src/"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "clean": "rm -rf dist",
     "build": "tsup src/index.ts --format cjs,esm --dts",
-    "type-check": "tsc --noEmit",
-    "prepublishOnly": "bun run type-check && bun run build"
+    "typecheck": "tsc --noEmit",
+    "release:check": "npm run typecheck && npm run build && npm pack --dry-run"
   },
   "dependencies": {},
   "devDependencies": {

package/src/client.ts

@@ -0,0 +1,16 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { type ClientOptions, type Config, createClient, createConfig } from './http';
+import type { ClientOptions as ClientOptions2 } from './types';
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
+
+export const client = createClient(createConfig<ClientOptions2>({ baseUrl: 'http://localhost:0' }));

package/src/config.ts

@@ -0,0 +1,16 @@
+import { client } from "./client";
+
+export interface SwapKitClientOptions {
+  apiKey: string;
+  baseUrl?: string;
+}
+
+export function configureSwapKit(options: SwapKitClientOptions) {
+  const { apiKey, baseUrl = "https://api.swapkit.dev" } = options;
+  client.setConfig({
+    baseUrl,
+    headers: { "x-api-key": apiKey },
+  });
+}
+
+export { client };

package/src/core/auth.ts

@@ -0,0 +1,41 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type AuthToken = string | undefined;
+
+export interface Auth {
+  /**
+   * Which part of the request do we use to send the auth?
+   *
+   * @default 'header'
+   */
+  in?: 'header' | 'query' | 'cookie';
+  /**
+   * Header or query parameter name.
+   *
+   * @default 'Authorization'
+   */
+  name?: string;
+  scheme?: 'basic' | 'bearer';
+  type: 'apiKey' | 'http';
+}
+
+export const getAuthToken = async (
+  auth: Auth,
+  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
+): Promise<string | undefined> => {
+  const token = typeof callback === 'function' ? await callback(auth) : callback;
+
+  if (!token) {
+    return;
+  }
+
+  if (auth.scheme === 'bearer') {
+    return `Bearer ${token}`;
+  }
+
+  if (auth.scheme === 'basic') {
+    return `Basic ${btoa(token)}`;
+  }
+
+  return token;
+};

package/src/core/bodySerializer.ts

@@ -0,0 +1,82 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { ArrayStyle, ObjectStyle, SerializerOptions } from './pathSerializer';
+
+export type QuerySerializer = (query: Record<string, unknown>) => string;
+
+export type BodySerializer = (body: unknown) => unknown;
+
+type QuerySerializerOptionsObject = {
+  allowReserved?: boolean;
+  array?: Partial<SerializerOptions<ArrayStyle>>;
+  object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+
+export type QuerySerializerOptions = QuerySerializerOptionsObject & {
+  /**
+   * Per-parameter serialization overrides. When provided, these settings
+   * override the global array/object settings for specific parameter names.
+   */
+  parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+const serializeFormDataPair = (data: FormData, key: string, value: unknown): void => {
+  if (typeof value === 'string' || value instanceof Blob) {
+    data.append(key, value);
+  } else if (value instanceof Date) {
+    data.append(key, value.toISOString());
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+};
+
+const serializeUrlSearchParamsPair = (data: URLSearchParams, key: string, value: unknown): void => {
+  if (typeof value === 'string') {
+    data.append(key, value);
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+};
+
+export const formDataBodySerializer = {
+  bodySerializer: (body: unknown): FormData => {
+    const data = new FormData();
+
+    Object.entries(body as Record<string, unknown>).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeFormDataPair(data, key, v));
+      } else {
+        serializeFormDataPair(data, key, value);
+      }
+    });
+
+    return data;
+  },
+};
+
+export const jsonBodySerializer = {
+  bodySerializer: (body: unknown): string =>
+    JSON.stringify(body, (_key, value) => (typeof value === 'bigint' ? value.toString() : value)),
+};
+
+export const urlSearchParamsBodySerializer = {
+  bodySerializer: (body: unknown): string => {
+    const data = new URLSearchParams();
+
+    Object.entries(body as Record<string, unknown>).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeUrlSearchParamsPair(data, key, v));
+      } else {
+        serializeUrlSearchParamsPair(data, key, value);
+      }
+    });
+
+    return data.toString();
+  },
+};

package/src/core/params.ts

@@ -0,0 +1,169 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+type Slot = 'body' | 'headers' | 'path' | 'query';
+
+export type Field =
+  | {
+      in: Exclude<Slot, 'body'>;
+      /**
+       * Field name. This is the name we want the user to see and use.
+       */
+      key: string;
+      /**
+       * Field mapped name. This is the name we want to use in the request.
+       * If omitted, we use the same value as `key`.
+       */
+      map?: string;
+    }
+  | {
+      in: Extract<Slot, 'body'>;
+      /**
+       * Key isn't required for bodies.
+       */
+      key?: string;
+      map?: string;
+    }
+  | {
+      /**
+       * Field name. This is the name we want the user to see and use.
+       */
+      key: string;
+      /**
+       * Field mapped name. This is the name we want to use in the request.
+       * If `in` is omitted, `map` aliases `key` to the transport layer.
+       */
+      map: Slot;
+    };
+
+export interface Fields {
+  allowExtra?: Partial<Record<Slot, boolean>>;
+  args?: ReadonlyArray<Field>;
+}
+
+export type FieldsConfig = ReadonlyArray<Field | Fields>;
+
+const extraPrefixesMap: Record<string, Slot> = {
+  $body_: 'body',
+  $headers_: 'headers',
+  $path_: 'path',
+  $query_: 'query',
+};
+const extraPrefixes = Object.entries(extraPrefixesMap);
+
+type KeyMap = Map<
+  string,
+  | {
+      in: Slot;
+      map?: string;
+    }
+  | {
+      in?: never;
+      map: Slot;
+    }
+>;
+
+const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
+  if (!map) {
+    map = new Map();
+  }
+
+  for (const config of fields) {
+    if ('in' in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map,
+        });
+      }
+    } else if ('key' in config) {
+      map.set(config.key, {
+        map: config.map,
+      });
+    } else if (config.args) {
+      buildKeyMap(config.args, map);
+    }
+  }
+
+  return map;
+};
+
+interface Params {
+  body: unknown;
+  headers: Record<string, unknown>;
+  path: Record<string, unknown>;
+  query: Record<string, unknown>;
+}
+
+const stripEmptySlots = (params: Params) => {
+  for (const [slot, value] of Object.entries(params)) {
+    if (value && typeof value === 'object' && !Array.isArray(value) && !Object.keys(value).length) {
+      delete params[slot as Slot];
+    }
+  }
+};
+
+export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsConfig) => {
+  const params: Params = {
+    body: {},
+    headers: {},
+    path: {},
+    query: {},
+  };
+
+  const map = buildKeyMap(fields);
+
+  let config: FieldsConfig[number] | undefined;
+
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index];
+    }
+
+    if (!config) {
+      continue;
+    }
+
+    if ('in' in config) {
+      if (config.key) {
+        const field = map.get(config.key)!;
+        const name = field.map || config.key;
+        if (field.in) {
+          (params[field.in] as Record<string, unknown>)[name] = arg;
+        }
+      } else {
+        params.body = arg;
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key);
+
+        if (field) {
+          if (field.in) {
+            const name = field.map || key;
+            (params[field.in] as Record<string, unknown>)[name] = value;
+          } else {
+            params[field.map] = value;
+          }
+        } else {
+          const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
+
+          if (extra) {
+            const [prefix, slot] = extra;
+            (params[slot] as Record<string, unknown>)[key.slice(prefix.length)] = value;
+          } else if ('allowExtra' in config && config.allowExtra) {
+            for (const [slot, allowed] of Object.entries(config.allowExtra)) {
+              if (allowed) {
+                (params[slot as Slot] as Record<string, unknown>)[key] = value;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  stripEmptySlots(params);
+
+  return params;
+};