@upbit-official/upbit-sdk 0.9.0

package/src/core/EventEmitter.ts

@@ -0,0 +1,114 @@
+type EventListener<Events, EventType extends keyof Events> = Events[EventType];
+
+type EventListeners<Events, EventType extends keyof Events> = Array<{
+  listener: EventListener<Events, EventType>;
+  once?: boolean;
+}>;
+
+export type EventParameters<Events, EventType extends keyof Events> = {
+  [Event in EventType]: EventListener<Events, EventType> extends (...args: infer P) => any ? P : never;
+}[EventType];
+
+export class EventEmitter<EventTypes extends Record<string, (...args: any) => any>> {
+  #listeners: {
+    [Event in keyof EventTypes]?: EventListeners<EventTypes, Event>;
+  } = {};
+
+  /**
+   * Adds the listener function to the end of the listeners array for the event.
+   * No checks are made to see if the listener has already been added. Multiple calls passing
+   * the same combination of event and listener will result in the listener being added, and
+   * called, multiple times.
+   * @returns this, so that calls can be chained
+   */
+  on<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
+    const listeners: EventListeners<EventTypes, Event> =
+      this.#listeners[event] || (this.#listeners[event] = []);
+    listeners.push({ listener });
+    return this;
+  }
+
+  /**
+   * Removes the specified listener from the listener array for the event.
+   * off() will remove, at most, one instance of a listener from the listener array. If any single
+   * listener has been added multiple times to the listener array for the specified event, then
+   * off() must be called multiple times to remove each instance.
+   * @returns this, so that calls can be chained
+   */
+  off<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
+    const listeners = this.#listeners[event];
+    if (!listeners) return this;
+    const index = listeners.findIndex((l) => l.listener === listener);
+    if (index >= 0) listeners.splice(index, 1);
+    return this;
+  }
+
+  /**
+   * Adds a one-time listener function for the event. The next time the event is triggered,
+   * this listener is removed and then invoked.
+   * @returns this, so that calls can be chained
+   */
+  once<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
+    const listeners: EventListeners<EventTypes, Event> =
+      this.#listeners[event] || (this.#listeners[event] = []);
+    listeners.push({ listener, once: true });
+    return this;
+  }
+
+  /**
+   * This is similar to `.once()`, but returns a Promise that resolves the next time
+   * the event is triggered, instead of calling a listener callback.
+   * @returns a Promise that resolves the next time given event is triggered,
+   * or rejects if an error is emitted.  (If you request the 'error' event,
+   * returns a promise that resolves with the error).
+   *
+   * Example:
+   *
+   *   const message = await stream.emitted('message') // rejects if the stream errors
+   */
+  emitted<Event extends keyof EventTypes>(
+    event: Event,
+  ): Promise<
+    EventParameters<EventTypes, Event> extends [infer Param] ? Param
+    : EventParameters<EventTypes, Event> extends [] ? void
+    : EventParameters<EventTypes, Event>
+  > {
+    return new Promise((resolve, reject) => {
+      // TODO: handle errors
+      this.once(event, resolve as any);
+    });
+  }
+
+  protected _emit<Event extends keyof EventTypes>(
+    this: EventEmitter<EventTypes>,
+    event: Event,
+    ...args: EventParameters<EventTypes, Event>
+  ) {
+    const listeners: EventListeners<EventTypes, Event> | undefined = this.#listeners[event];
+    if (listeners) {
+      this.#listeners[event] = listeners.filter((l) => !l.once) as any;
+      listeners.forEach(({ listener }: any) => listener(...(args as any)));
+    }
+  }
+
+  protected _hasListener(event: keyof EventTypes): boolean {
+    const listeners = this.#listeners[event];
+    return listeners && listeners.length > 0;
+  }
+}
+
+/**
+ * An EventEmitter variant that exposes `_emit()` publicly.
+ *
+ * The base {@link EventEmitter} keeps `_emit` protected so that consumers
+ * can only listen, not dispatch. When you need a separate emitter instance
+ * that your own code can emit on, without exposing emit on the
+ * consumer-facing emitter, use this class.
+ */
+export class InternalEventEmitter<
+  EventTypes extends Record<string, (...args: any) => any>,
+> extends EventEmitter<EventTypes> {
+  override _emit<Event extends keyof EventTypes>(event: Event, ...args: EventParameters<EventTypes, Event>) {
+    super._emit(event, ...args);
+  }
+}

package/src/core/README.md

@@ -0,0 +1,3 @@
+# `core`
+
+This directory holds public modules implementing non-resource-specific SDK functionality.

package/src/core/api-promise.ts

@@ -0,0 +1,91 @@
+
+import { type Upbit } from '../client';
+
+import { type PromiseOrValue } from '../internal/types';
+import { APIResponseProps, defaultParseResponse } from '../internal/parse';
+
+/**
+ * A subclass of `Promise` providing additional helper methods
+ * for interacting with the SDK.
+ */
+export class APIPromise<T> extends Promise<T> {
+  private parsedPromise: Promise<T> | undefined;
+  #client: Upbit;
+
+  constructor(
+    client: Upbit,
+    private responsePromise: Promise<APIResponseProps>,
+    private parseResponse: (
+      client: Upbit,
+      props: APIResponseProps,
+    ) => PromiseOrValue<T> = defaultParseResponse,
+  ) {
+    super((resolve) => {
+      // this is maybe a bit weird but this has to be a no-op to not implicitly
+      // parse the response body; instead .then, .catch, .finally are overridden
+      // to parse the response
+      resolve(null as any);
+    });
+    this.#client = client;
+  }
+
+  _thenUnwrap<U>(transform: (data: T, props: APIResponseProps) => U): APIPromise<U> {
+    return new APIPromise(this.#client, this.responsePromise, async (client, props) =>
+      transform(await this.parseResponse(client, props), props),
+    );
+  }
+
+  /**
+   * Gets the raw `Response` instance instead of parsing the response
+   * data.
+   *
+   * If you want to parse the response body but still get the `Response`
+   * instance, you can use {@link withResponse()}.
+   *
+   * Getting the wrong TypeScript type for `Response`?
+   * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
+   * to your `tsconfig.json`.
+   */
+  asResponse(): Promise<Response> {
+    return this.responsePromise.then((p) => p.response);
+  }
+
+  /**
+   * Gets the parsed response data and the raw `Response` instance.
+   *
+   * If you just want to get the raw `Response` instance without parsing it,
+   * you can use {@link asResponse()}.
+   *
+   * Getting the wrong TypeScript type for `Response`?
+   * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
+   * to your `tsconfig.json`.
+   */
+  async withResponse(): Promise<{ data: T; response: Response }> {
+    const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+    return { data, response };
+  }
+
+  private parse(): Promise<T> {
+    if (!this.parsedPromise) {
+      this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(this.#client, data));
+    }
+    return this.parsedPromise;
+  }
+
+  override then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+
+  override catch<TResult = never>(
+    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null,
+  ): Promise<T | TResult> {
+    return this.parse().catch(onrejected);
+  }
+
+  override finally(onfinally?: (() => void) | undefined | null): Promise<T> {
+    return this.parse().finally(onfinally);
+  }
+}

package/src/core/error.ts

@@ -0,0 +1,182 @@
+
+import { castToError } from '../internal/errors';
+
+export class UpbitError extends Error {}
+
+export class APIError<
+  TStatus extends number | undefined = number | undefined,
+  THeaders extends Headers | undefined = Headers | undefined,
+  TError extends Object | undefined = Object | undefined,
+> extends UpbitError {
+  /** HTTP status for the response that caused the error */
+  readonly status: TStatus;
+  /** HTTP headers for the response that caused the error */
+  readonly headers: THeaders;
+  /** JSON body of the response that caused the error */
+  readonly error: TError;
+  /** Upbit API error name (e.g. "not_found", "invalid_query_payload") */
+  override readonly name: string;
+
+  constructor(
+    status: TStatus,
+    error: TError,
+    message: string | undefined,
+    headers: THeaders,
+    name?: string | null,
+  ) {
+    super(`${APIError.makeMessage(status, error, message, name ?? null)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+    this.name = name ?? '';
+  }
+
+  private static makeMessage(
+    status: number | undefined,
+    error: any,
+    message: string | undefined,
+    name: string | null,
+  ) {
+    const errorBody =
+      error && typeof error === 'object' && !Array.isArray(error) && Object.keys(error).length > 0 ?
+        error
+      : undefined;
+    const msg =
+      message ??
+      (errorBody?.message ?
+        typeof errorBody.message === 'string' ?
+          errorBody.message
+        : JSON.stringify(errorBody.message)
+      : errorBody ? JSON.stringify(errorBody)
+      : undefined);
+
+    if (status && msg) {
+      return name ? `${status} [${name}] ${msg}` : `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return '(no status code or body)';
+  }
+
+  private static parseErrorBody(error: any): { message: string | null; name: string | null } {
+    if (!error || typeof error !== 'object' || Array.isArray(error)) {
+      return { message: null, name: null };
+    }
+    // Shape B: {"error": {"name": "...", "message": "..."}}
+    const nested = error['error'];
+    if (nested != null && typeof nested === 'object' && !Array.isArray(nested)) {
+      const rawName = nested['name'];
+      const rawMessage = nested['message'];
+      return {
+        message: rawMessage != null ? String(rawMessage) : null,
+        name: rawName != null ? String(rawName) : null,
+      };
+    }
+    // Shape A: {"name": "...", "message": "..."}
+    const rawName = error['name'];
+    if (rawName != null) {
+      const rawMessage = error['message'];
+      return {
+        message: rawMessage != null ? String(rawMessage) : null,
+        name: String(rawName),
+      };
+    }
+    return { message: null, name: null };
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ): APIError {
+    if (!status || !headers) {
+      return new APIConnectionError({ message, cause: castToError(errorResponse) });
+    }
+
+    const error = errorResponse as Record<string, any>;
+    const { name: errorName, message: parsedMessage } = APIError.parseErrorBody(error);
+    const resolvedMessage = parsedMessage ?? message;
+
+    if (status === 400) {
+      return new BadRequestError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    if (status === 401) {
+      return new AuthenticationError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    if (status === 404) {
+      return new NotFoundError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    if (status === 409) {
+      return new ConflictError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    if (status === 418) {
+      return new RateLimitPenaltyError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    if (status === 429) {
+      return new RateLimitError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    if (status >= 500) {
+      return new InternalServerError(status, error, resolvedMessage, headers, errorName);
+    }
+
+    return new APIError(status, error, resolvedMessage, headers, errorName);
+  }
+}
+
+export class APIUserAbortError extends APIError<undefined, undefined, undefined> {
+  constructor({ message }: { message?: string } = {}) {
+    super(undefined, undefined, message || 'Request was aborted.', undefined);
+  }
+}
+
+export class APIConnectionError extends APIError<undefined, undefined, undefined> {
+  constructor({ message, cause }: { message?: string | undefined; cause?: Error | undefined }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    // in some environments the 'cause' property is already declared
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+
+export class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message }: { message?: string } = {}) {
+    super({ message: message ?? 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError<400, Headers> {}
+
+export class AuthenticationError extends APIError<401, Headers> {}
+
+export class PermissionDeniedError extends APIError<403, Headers> {}
+
+export class NotFoundError extends APIError<404, Headers> {}
+
+export class ConflictError extends APIError<409, Headers> {}
+
+export class UnprocessableEntityError extends APIError<422, Headers> {}
+
+export class RateLimitError extends APIError<429, Headers> {}
+
+export class RateLimitPenaltyError extends APIError<418, Headers> {}
+
+export class InternalServerError extends APIError<number, Headers> {}

package/src/core/pagination.ts

@@ -0,0 +1,195 @@
+
+import { UpbitError } from './error';
+import { FinalRequestOptions } from '../internal/request-options';
+import { defaultParseResponse } from '../internal/parse';
+import { type Upbit } from '../client';
+import { APIPromise } from './api-promise';
+import { type APIResponseProps } from '../internal/parse';
+import { maybeObj } from '../internal/utils/values';
+
+export type PageRequestOptions = Pick<FinalRequestOptions, 'query' | 'headers' | 'body' | 'path' | 'method'>;
+
+export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
+  #client: Upbit;
+  protected options: FinalRequestOptions;
+
+  protected response: Response;
+  protected body: unknown;
+
+  constructor(client: Upbit, response: Response, body: unknown, options: FinalRequestOptions) {
+    this.#client = client;
+    this.options = options;
+    this.response = response;
+    this.body = body;
+  }
+
+  abstract nextPageRequestOptions(): PageRequestOptions | null;
+
+  abstract getPaginatedItems(): Item[];
+
+  hasNextPage(): boolean {
+    const items = this.getPaginatedItems();
+    if (!items.length) return false;
+    return this.nextPageRequestOptions() != null;
+  }
+
+  async getNextPage(): Promise<this> {
+    const nextOptions = this.nextPageRequestOptions();
+    if (!nextOptions) {
+      throw new UpbitError(
+        'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
+      );
+    }
+
+    return await this.#client.requestAPIList(this.constructor as any, nextOptions);
+  }
+
+  async *iterPages(): AsyncGenerator<this> {
+    let page: this = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+}
+
+/**
+ * This subclass of Promise will resolve to an instantiated Page once the request completes.
+ *
+ * It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg:
+ *
+ *    for await (const item of client.items.list()) {
+ *      console.log(item)
+ *    }
+ */
+export class PagePromise<
+    PageClass extends AbstractPage<Item>,
+    Item = ReturnType<PageClass['getPaginatedItems']>[number],
+  >
+  extends APIPromise<PageClass>
+  implements AsyncIterable<Item>
+{
+  constructor(
+    client: Upbit,
+    request: Promise<APIResponseProps>,
+    Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
+  ) {
+    super(
+      client,
+      request,
+      async (client, props) =>
+        new Page(client, props.response, await defaultParseResponse(client, props), props.options),
+    );
+  }
+
+  /**
+   * Allow auto-paginating iteration on an unawaited list call, eg:
+   *
+   *    for await (const item of client.items.list()) {
+   *      console.log(item)
+   *    }
+   */
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+}
+
+export type PageNumberPageResponse<Item> = Item[];
+
+export interface PageNumberPageParams {
+  page?: number;
+
+  limit?: number;
+}
+
+export class PageNumberPage<Item> extends AbstractPage<Item> {
+  items: Array<Item>;
+
+  constructor(
+    client: Upbit,
+    response: Response,
+    body: PageNumberPageResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.items = body || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.items ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const query = this.options.query as PageNumberPageParams;
+    const currentPage = query?.page ?? 1;
+    const limit = query?.limit;
+
+    if (limit !== undefined && this.getPaginatedItems().length < limit) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        page: currentPage + 1,
+      },
+    };
+  }
+}
+
+export type UuidCursorIDPageResponse<Item> = Item[];
+
+export interface UuidCursorIDPageParams {
+  to?: string;
+
+  limit?: number;
+}
+
+export class UuidCursorIDPage<Item extends { uuid: string }> extends AbstractPage<Item> {
+  items: Array<Item>;
+
+  constructor(
+    client: Upbit,
+    response: Response,
+    body: UuidCursorIDPageResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.items = body || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.items ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const items = this.getPaginatedItems();
+    const uuid = items[items.length - 1]?.uuid;
+    if (!uuid) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        to: uuid,
+      },
+    };
+  }
+}

package/src/core/resource.ts

@@ -0,0 +1,10 @@
+
+import type { Upbit } from '../client';
+
+export abstract class APIResource {
+  protected _client: Upbit;
+
+  constructor(client: Upbit) {
+    this._client = client;
+  }
+}

package/src/core/uploads.ts

@@ -0,0 +1,2 @@
+export { type Uploadable } from '../internal/uploads';
+export { toFile, type ToFileInput } from '../internal/to-file';

package/src/error.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/error instead */
+export * from './core/error';

package/src/index.ts

@@ -0,0 +1,24 @@
+
+export { Upbit as default } from './client';
+export { createJwtToken, WsStream, WsStreamManager, type WsStreamOptions } from './lib';
+
+export { type Uploadable, toFile } from './core/uploads';
+export { APIPromise } from './core/api-promise';
+export { Upbit, type ClientOptions } from './client';
+export { PagePromise } from './core/pagination';
+export {
+  UpbitError,
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIUserAbortError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  RateLimitPenaltyError,
+  BadRequestError,
+  AuthenticationError,
+  InternalServerError,
+  PermissionDeniedError,
+  UnprocessableEntityError,
+} from './core/error';

package/src/internal/README.md

@@ -0,0 +1,3 @@
+# `internal`
+
+The modules in this directory are not importable outside this package and will change between releases.