@openally/github.sdk 1.1.0 → 1.1.1

package/src/api/rawFile.ts

@@ -1,73 +0,0 @@
-// Import Internal Dependencies
-import {
-  DEFAULT_USER_AGENT,
-  GITHUB_RAW_API
-} from "../constants.ts";
-import type { RequestConfig } from "../types.ts";
-
-// CONSTANTS
-const kDefaultRef = "HEAD";
-
-export interface FetchRawFileOptions extends RequestConfig {
-  /**
-   * Branch, tag, or commit SHA.
-   * @default "HEAD"
-   */
-  ref?: string;
-}
-
-export type FetchRawFileClientOptions = Omit<FetchRawFileOptions, "token" | "userAgent">;
-export type RawFileParser<T> = "json" | ((content: string) => T);
-
-export function fetchRawFile(
-  repository: `${string}/${string}`,
-  filePath: string,
-  options?: FetchRawFileOptions & { parser?: undefined; }
-): Promise<string>;
-export function fetchRawFile<T = unknown>(
-  repository: `${string}/${string}`,
-  filePath: string,
-  options: FetchRawFileOptions & { parser: "json"; }
-): Promise<T>;
-export function fetchRawFile<T>(
-  repository: `${string}/${string}`,
-  filePath: string,
-  options: FetchRawFileOptions & { parser: (content: string) => T; }
-): Promise<T>;
-export async function fetchRawFile<T>(
-  repository: `${string}/${string}`,
-  filePath: string,
-  options: FetchRawFileOptions & { parser?: RawFileParser<T>; } = {}
-): Promise<string | T> {
-  const {
-    ref = kDefaultRef,
-    token,
-    userAgent = DEFAULT_USER_AGENT,
-    parser
-  } = options;
-
-  const url = new URL(`${repository}/${ref}/${filePath}`, GITHUB_RAW_API);
-  const headers: Record<string, string> = {
-    "User-Agent": userAgent,
-    ...(typeof token === "string" ? { Authorization: `token ${token}` } : {})
-  };
-
-  const response = await fetch(url, { headers });
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch raw file '${filePath}' from ${repository}@${ref}: HTTP ${response.status}`
-    );
-  }
-
-  const content = await response.text();
-
-  if (parser === "json") {
-    return JSON.parse(content) as T;
-  }
-  if (typeof parser === "function") {
-    return parser(content);
-  }
-
-  return content;
-}

package/src/api/repos.ts

@@ -1,88 +0,0 @@
-// Import Internal Dependencies
-import { ApiEndpoint } from "../class/ApiEndpoint.ts";
-import { createApiProxy } from "../class/createApiProxy.ts";
-import type {
-  Tag,
-  PullRequest,
-  Issue,
-  Commit,
-  Workflow,
-  WorkflowRun,
-  Job,
-  Artifact,
-  WorkflowsResponse,
-  WorkflowRunsResponse,
-  JobsResponse,
-  ArtifactsResponse,
-  RequestConfig
-} from "../types.ts";
-
-type RepoEndpointMethods = {
-  tags: () => ApiEndpoint<Tag>;
-  pulls: () => ApiEndpoint<PullRequest>;
-  issues: () => ApiEndpoint<Issue>;
-  commits: () => ApiEndpoint<Commit>;
-  workflows: () => ApiEndpoint<Workflow>;
-  workflowRuns: (workflowId: string | number) => ApiEndpoint<WorkflowRun>;
-  runJobs: (runId: number) => ApiEndpoint<Job>;
-  runArtifacts: (runId: number) => ApiEndpoint<Artifact>;
-};
-
-export type ReposProxy = {
-  [owner: string]: {
-    [repo: string]: RepoEndpointMethods;
-  };
-};
-
-function createRepoProxy(
-  owner: string,
-  repo: string,
-  config: RequestConfig = {}
-): RepoEndpointMethods {
-  return {
-    tags: () => new ApiEndpoint<Tag>(`/repos/${owner}/${repo}/tags`, config),
-    pulls: () => new ApiEndpoint<PullRequest>(`/repos/${owner}/${repo}/pulls`, config),
-    issues: () => new ApiEndpoint<Issue>(`/repos/${owner}/${repo}/issues`, config),
-    commits: () => new ApiEndpoint<Commit>(`/repos/${owner}/${repo}/commits`, config),
-    workflows: () => new ApiEndpoint<Workflow>(
-      `/repos/${owner}/${repo}/actions/workflows`,
-      {
-        ...config,
-        extractor: (raw: WorkflowsResponse) => raw.workflows
-      }
-    ),
-    workflowRuns: (workflowId: string | number) => new ApiEndpoint<WorkflowRun>(
-      `/repos/${owner}/${repo}/actions/workflows/${workflowId}/runs`,
-      {
-        ...config,
-        extractor: (raw: WorkflowRunsResponse) => raw.workflow_runs
-      }
-    ),
-    runJobs: (runId: number) => new ApiEndpoint<Job>(
-      `/repos/${owner}/${repo}/actions/runs/${runId}/jobs`,
-      {
-        ...config,
-        extractor: (raw: JobsResponse) => raw.jobs
-      }
-    ),
-    runArtifacts: (runId: number) => new ApiEndpoint<Artifact>(
-      `/repos/${owner}/${repo}/actions/runs/${runId}/artifacts`,
-      {
-        ...config,
-        extractor: (raw: ArtifactsResponse) => raw.artifacts
-      }
-    )
-  };
-}
-
-export function createReposProxy(
-  config: RequestConfig = {}
-): ReposProxy {
-  return createApiProxy(
-    (owner) => createApiProxy(
-      (repo) => createRepoProxy(owner, repo, config)
-    )
-  ) as ReposProxy;
-}
-
-export const repos = createReposProxy();

package/src/api/users.ts

@@ -1,51 +0,0 @@
-// Import Internal Dependencies
-import { ApiEndpoint } from "../class/ApiEndpoint.ts";
-import { createApiProxy } from "../class/createApiProxy.ts";
-import type {
-  UserOrg,
-  UserRepo,
-  UserGist,
-  UserFollower,
-  UserFollowing,
-  UserStarred,
-  RequestConfig
-} from "../types.ts";
-
-// CONSTANTS
-const kUserEndpointResponseMap = {
-  orgs: {} as UserOrg,
-  repos: {} as UserRepo,
-  gists: {} as UserGist,
-  followers: {} as UserFollower,
-  following: {} as UserFollowing,
-  starred: {} as UserStarred
-};
-
-type UserEndpoint = keyof typeof kUserEndpointResponseMap;
-type UserEndpointMethods = {
-  [K in UserEndpoint]: () => ApiEndpoint<typeof kUserEndpointResponseMap[K]>;
-};
-export type UsersProxy = {
-  [username: string]: UserEndpointMethods;
-};
-
-function createUserProxy(
-  username: string,
-  config: RequestConfig = {}
-) {
-  return Object.fromEntries(
-    Object.keys(kUserEndpointResponseMap).map(
-      (endpoint) => [endpoint, () => new ApiEndpoint(`/users/${username}/${endpoint}`, config)]
-    )
-  );
-}
-
-export function createUsersProxy(
-  config: RequestConfig = {}
-): UsersProxy {
-  return createApiProxy(
-    (username) => createUserProxy(username, config)
-  ) as UsersProxy;
-}
-
-export const users = createUsersProxy();

package/src/class/ApiEndpoint.ts

@@ -1,108 +0,0 @@
-// Import Internal Dependencies
-import { HttpLinkParser } from "./HttpLinkParser.ts";
-import {
-  DEFAULT_USER_AGENT,
-  GITHUB_API
-} from "../constants.ts";
-import type { RequestConfig } from "../types.ts";
-
-export interface ApiEndpointOptions<T> extends RequestConfig {
-  /**
-   * By default, the raw response from the GitHub API is returned as-is.
-   * You can provide a custom extractor function to transform the raw response
-   * into an array of type T.
-   */
-  extractor?: (raw: any) => T[];
-}
-
-export class ApiEndpoint<T> {
-  #userAgent: string;
-  #bearerToken?: string;
-
-  #nextURL: string | null = null;
-  #apiEndpoint: string | URL;
-  #extractor: (raw: any) => T[];
-
-  constructor(
-    apiEndpoint: string | URL,
-    options: ApiEndpointOptions<T> = {}
-  ) {
-    const {
-      userAgent = DEFAULT_USER_AGENT,
-      token,
-      extractor = ((raw) => raw as T[])
-    } = options;
-
-    this.#userAgent = userAgent;
-    this.#bearerToken = token;
-    this.#apiEndpoint = apiEndpoint;
-    this.#extractor = extractor;
-  }
-
-  setBearerToken(
-    token: string
-  ): this {
-    this.#bearerToken = token;
-
-    return this;
-  }
-
-  setAgent(
-    userAgent: string
-  ): this {
-    this.#userAgent = userAgent;
-
-    return this;
-  }
-
-  async #next(): Promise<T[]> {
-    const headers = {
-      "User-Agent": this.#userAgent,
-      Accept: "application/vnd.github.v3.raw",
-      ...(
-        typeof this.#bearerToken === "string" ?
-          { Authorization: `token ${this.#bearerToken}` } :
-          {}
-      )
-    };
-
-    const url = this.#nextURL === null ?
-      new URL(this.#apiEndpoint, GITHUB_API) :
-      new URL(this.#nextURL, GITHUB_API);
-    const response = await fetch(
-      url,
-      { headers }
-    );
-    const rawData = await response.json();
-
-    const linkHeader = response.headers.get("link");
-    this.#nextURL = linkHeader
-      ? HttpLinkParser.parse(linkHeader).get("next") ?? null
-      : null;
-
-    return this.#extractor(rawData);
-  }
-
-  async* iterate(): AsyncIterableIterator<T> {
-    do {
-      const pageResults = await this.#next();
-
-      yield* pageResults;
-    } while (this.#nextURL !== null);
-  }
-
-  [Symbol.asyncIterator](): AsyncIterableIterator<T> {
-    return this.iterate();
-  }
-
-  all(): Promise<T[]> {
-    return Array.fromAsync(this.iterate());
-  }
-
-  then<TResult1 = T[], TResult2 = never>(
-    onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null,
-    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
-  ): Promise<TResult1 | TResult2> {
-    return this.all().then(onfulfilled, onrejected);
-  }
-}

package/src/class/GithubClient.ts

@@ -1,62 +0,0 @@
-// Import Internal Dependencies
-import {
-  createUsersProxy,
-  type UsersProxy
-} from "../api/users.ts";
-import {
-  createReposProxy,
-  type ReposProxy
-} from "../api/repos.ts";
-import {
-  fetchRawFile,
-  type FetchRawFileClientOptions,
-  type RawFileParser
-} from "../api/rawFile.ts";
-import type { RequestConfig } from "../types.ts";
-
-export interface GithubClientOptions extends RequestConfig {}
-
-export class GithubClient {
-  readonly users: UsersProxy;
-  readonly repos: ReposProxy;
-  #config: RequestConfig;
-
-  constructor(
-    options: GithubClientOptions = {}
-  ) {
-    this.#config = {
-      token: options.token,
-      userAgent: options.userAgent
-    };
-
-    this.users = createUsersProxy(this.#config);
-    this.repos = createReposProxy(this.#config);
-  }
-
-  fetchRawFile(
-    repository: `${string}/${string}`,
-    filePath: string,
-    options?: FetchRawFileClientOptions & { parser?: undefined; }
-  ): Promise<string>;
-  fetchRawFile<T = unknown>(
-    repository: `${string}/${string}`,
-    filePath: string,
-    options: FetchRawFileClientOptions & { parser: "json"; }
-  ): Promise<T>;
-  fetchRawFile<T>(
-    repository: `${string}/${string}`,
-    filePath: string,
-    options: FetchRawFileClientOptions & { parser: (content: string) => T; }
-  ): Promise<T>;
-  fetchRawFile<T>(
-    repository: `${string}/${string}`,
-    filePath: string,
-    options: FetchRawFileClientOptions & { parser?: RawFileParser<T>; } = {}
-  ): Promise<string | T> {
-    return fetchRawFile<T>(
-      repository,
-      filePath,
-      { ...this.#config, ...options } as any
-    );
-  }
-}

package/src/class/HttpLinkParser.ts

@@ -1,17 +0,0 @@
-export class HttpLinkParser {
-  static parse(
-    headerValue: string
-  ): Map<string, string> {
-    const result = new Map<string, string>();
-
-    for (const part of headerValue.split(", ")) {
-      const urlMatch = part.match(/^<([^>]+)>/);
-      const relMatch = part.match(/rel="([^"]+)"/);
-      if (urlMatch && relMatch) {
-        result.set(relMatch[1], urlMatch[1]);
-      }
-    }
-
-    return result;
-  }
-}

package/src/class/createApiProxy.ts

@@ -1,9 +0,0 @@
-export function createApiProxy<T>(
-  factory: (key: string) => T
-): Record<string, T> {
-  return new Proxy(Object.create(null), {
-    get(_, key: string) {
-      return factory(key);
-    }
-  }) as Record<string, T>;
-}