@openally/github.sdk 1.0.0 → 1.1.1

package/test/HttpLinkParser.spec.ts

@@ -1,78 +0,0 @@
-// Import Node.js Dependencies
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-// Import Internal Dependencies
-import { HttpLinkParser } from "../src/class/HttpLinkParser.ts";
-
-describe("HttpLinkParser", () => {
-  describe("parse()", () => {
-    it("should return a Map instance", () => {
-      const result = HttpLinkParser.parse("");
-
-      assert.ok(result instanceof Map);
-    });
-
-    it("should return an empty map for an empty string", () => {
-      const result = HttpLinkParser.parse("");
-
-      assert.equal(result.size, 0);
-    });
-
-    it("should return an empty map for a malformed header", () => {
-      const result = HttpLinkParser.parse("not a link header");
-
-      assert.equal(result.size, 0);
-    });
-
-    it("should parse a single link relation", () => {
-      const header = '<https://api.github.com/repos/foo/bar/tags?page=2>; rel="next"';
-      const result = HttpLinkParser.parse(header);
-
-      assert.equal(result.size, 1);
-      assert.equal(result.get("next"), "https://api.github.com/repos/foo/bar/tags?page=2");
-    });
-
-    it("should parse multiple link relations", () => {
-      const header = [
-        '<https://api.github.com/repos/foo/bar/tags?page=2>; rel="next"',
-        '<https://api.github.com/repos/foo/bar/tags?page=5>; rel="last"'
-      ].join(", ");
-      const result = HttpLinkParser.parse(header);
-
-      assert.equal(result.size, 2);
-      assert.equal(result.get("next"), "https://api.github.com/repos/foo/bar/tags?page=2");
-      assert.equal(result.get("last"), "https://api.github.com/repos/foo/bar/tags?page=5");
-    });
-
-    it("should parse all four standard link relations", () => {
-      const header = [
-        '<https://api.github.com/repos/foo/bar/tags?page=2>; rel="next"',
-        '<https://api.github.com/repos/foo/bar/tags?page=5>; rel="last"',
-        '<https://api.github.com/repos/foo/bar/tags?page=1>; rel="first"',
-        '<https://api.github.com/repos/foo/bar/tags?page=1>; rel="prev"'
-      ].join(", ");
-      const result = HttpLinkParser.parse(header);
-
-      assert.equal(result.size, 4);
-      assert.ok(result.has("next"));
-      assert.ok(result.has("last"));
-      assert.ok(result.has("first"));
-      assert.ok(result.has("prev"));
-    });
-
-    it("should ignore parts that have no URL match", () => {
-      const header = 'no-url; rel="next"';
-      const result = HttpLinkParser.parse(header);
-
-      assert.equal(result.size, 0);
-    });
-
-    it("should ignore parts that have no rel match", () => {
-      const header = "<https://api.github.com/repos/foo/bar/tags?page=2>";
-      const result = HttpLinkParser.parse(header);
-
-      assert.equal(result.size, 0);
-    });
-  });
-});

package/test/createApiProxy.spec.ts

@@ -1,58 +0,0 @@
-/* eslint-disable no-unused-expressions */
-// Import Node.js Dependencies
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-// Import Internal Dependencies
-import { createApiProxy } from "../src/class/createApiProxy.ts";
-
-describe("createApiProxy", () => {
-  it("should call the factory with the accessed property key", () => {
-    const proxy = createApiProxy((key: string) => key.toUpperCase());
-
-    assert.equal(proxy.hello, "HELLO");
-    assert.equal(proxy.world, "WORLD");
-  });
-
-  it("should call the factory on each property access", () => {
-    let callCount = 0;
-    const proxy = createApiProxy((key: string) => {
-      callCount++;
-
-      return key;
-    });
-
-    proxy.a;
-    proxy.b;
-    proxy.a;
-
-    assert.equal(callCount, 3);
-  });
-
-  it("should return different values for different keys", () => {
-    const proxy = createApiProxy((key: string) => {
-      return { name: key };
-    });
-
-    assert.notDeepEqual(proxy.foo, proxy.bar);
-    assert.equal(proxy.foo.name, "foo");
-    assert.equal(proxy.bar.name, "bar");
-  });
-
-  it("should support nested proxies", () => {
-    const proxy = createApiProxy(
-      (owner: string) => createApiProxy(
-        (repo: string) => `${owner}/${repo}`
-      )
-    );
-
-    assert.equal(proxy.myorg.myrepo, "myorg/myrepo");
-    assert.equal(proxy.another.sdk, "another/sdk");
-  });
-
-  it("should return a plain object (no prototype)", () => {
-    const proxy = createApiProxy((key: string) => key);
-
-    assert.equal(Object.getPrototypeOf(proxy), null);
-  });
-});

package/test/repos.spec.ts

@@ -1,221 +0,0 @@
-// Import Node.js Dependencies
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-
-// Import Third-party Dependencies
-import { MockAgent, setGlobalDispatcher, getGlobalDispatcher, type Dispatcher } from "undici";
-
-// Import Internal Dependencies
-import { ApiEndpoint } from "../src/class/ApiEndpoint.ts";
-import { repos, createReposProxy } from "../src/api/repos.ts";
-
-// CONSTANTS
-const kGithubOrigin = "https://api.github.com";
-
-describe("Repos API", () => {
-  let mockAgent: MockAgent;
-  let originalDispatcher: Dispatcher;
-
-  beforeEach(() => {
-    originalDispatcher = getGlobalDispatcher();
-    mockAgent = new MockAgent();
-    mockAgent.disableNetConnect();
-    setGlobalDispatcher(mockAgent);
-  });
-
-  afterEach(async() => {
-    await mockAgent.close();
-    setGlobalDispatcher(originalDispatcher);
-  });
-
-  describe("createReposProxy()", () => {
-    it("should return an ApiEndpoint for each simple repo endpoint", () => {
-      const proxy = createReposProxy();
-      const methods = proxy.owner.myrepo;
-
-      assert.ok(methods.tags() instanceof ApiEndpoint);
-      assert.ok(methods.pulls() instanceof ApiEndpoint);
-      assert.ok(methods.issues() instanceof ApiEndpoint);
-      assert.ok(methods.commits() instanceof ApiEndpoint);
-      assert.ok(methods.workflows() instanceof ApiEndpoint);
-    });
-
-    it("should return an ApiEndpoint from workflowRuns() with a string workflow id", () => {
-      const endpoint = createReposProxy().owner.myrepo.workflowRuns("ci.yml");
-
-      assert.ok(endpoint instanceof ApiEndpoint);
-    });
-
-    it("should return an ApiEndpoint from workflowRuns() with a numeric workflow id", () => {
-      const endpoint = createReposProxy().owner.myrepo.workflowRuns(42);
-
-      assert.ok(endpoint instanceof ApiEndpoint);
-    });
-
-    it("should return an ApiEndpoint from runJobs()", () => {
-      const endpoint = createReposProxy().owner.myrepo.runJobs(123);
-
-      assert.ok(endpoint instanceof ApiEndpoint);
-    });
-
-    it("should return an ApiEndpoint from runArtifacts()", () => {
-      const endpoint = createReposProxy().owner.myrepo.runArtifacts(456);
-
-      assert.ok(endpoint instanceof ApiEndpoint);
-    });
-
-    it("should create a new ApiEndpoint on each method call", () => {
-      const proxy = createReposProxy();
-
-      assert.notStrictEqual(proxy.owner.myrepo.tags(), proxy.owner.myrepo.tags());
-    });
-
-    it("should pass the token from config to ApiEndpoints", async() => {
-      const proxy = createReposProxy({ token: "repotoken" });
-
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({
-          path: "/repos/owner/myrepo/tags",
-          method: "GET",
-          headers: { authorization: "token repotoken" }
-        })
-        .reply(200, JSON.stringify([]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      await assert.doesNotReject(proxy.owner.myrepo.tags().all());
-    });
-  });
-
-  describe("repos (default export)", () => {
-    it("should fetch tags for a repo", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/repos/octocat/hello-world/tags", method: "GET" })
-        .reply(200, JSON.stringify([{ name: "v1.0.0" }, { name: "v1.1.0" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].tags().all();
-
-      assert.deepEqual(result, [{ name: "v1.0.0" }, { name: "v1.1.0" }]);
-    });
-
-    it("should fetch pull requests for a repo", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/repos/octocat/hello-world/pulls", method: "GET" })
-        .reply(200, JSON.stringify([{ number: 1, title: "Fix bug" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].pulls().all();
-
-      assert.deepEqual(result, [{ number: 1, title: "Fix bug" }]);
-    });
-
-    it("should fetch issues for a repo", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/repos/octocat/hello-world/issues", method: "GET" })
-        .reply(200, JSON.stringify([{ number: 5, title: "Bug report" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].issues().all();
-
-      assert.deepEqual(result, [{ number: 5, title: "Bug report" }]);
-    });
-
-    it("should fetch commits for a repo", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/repos/octocat/hello-world/commits", method: "GET" })
-        .reply(200, JSON.stringify([{ sha: "abc123" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].commits().all();
-
-      assert.deepEqual(result, [{ sha: "abc123" }]);
-    });
-
-    it("should fetch workflows using the extractor", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/repos/octocat/hello-world/actions/workflows", method: "GET" })
-        .reply(200, JSON.stringify({ total_count: 1, workflows: [{ id: 1, name: "CI" }] }), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].workflows().all();
-
-      assert.deepEqual(result, [{ id: 1, name: "CI" }]);
-    });
-
-    it("should fetch workflow runs by string workflow id using the extractor", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({
-          path: "/repos/octocat/hello-world/actions/workflows/ci.yml/runs",
-          method: "GET"
-        })
-        .reply(200, JSON.stringify({ total_count: 1, workflow_runs: [{ id: 100, status: "completed" }] }), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].workflowRuns("ci.yml").all();
-
-      assert.deepEqual(result, [{ id: 100, status: "completed" }]);
-    });
-
-    it("should fetch workflow runs by numeric workflow id using the extractor", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({
-          path: "/repos/octocat/hello-world/actions/workflows/42/runs",
-          method: "GET"
-        })
-        .reply(200, JSON.stringify({ total_count: 2, workflow_runs: [{ id: 200 }, { id: 201 }] }), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].workflowRuns(42).all();
-
-      assert.deepEqual(result, [{ id: 200 }, { id: 201 }]);
-    });
-
-    it("should fetch run jobs using the extractor", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({
-          path: "/repos/octocat/hello-world/actions/runs/999/jobs",
-          method: "GET"
-        })
-        .reply(200, JSON.stringify({ total_count: 1, jobs: [{ id: 10, name: "build" }] }), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].runJobs(999).all();
-
-      assert.deepEqual(result, [{ id: 10, name: "build" }]);
-    });
-
-    it("should fetch run artifacts using the extractor", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({
-          path: "/repos/octocat/hello-world/actions/runs/999/artifacts",
-          method: "GET"
-        })
-        .reply(200, JSON.stringify({ total_count: 1, artifacts: [{ id: 55, name: "build-output" }] }), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await repos.octocat["hello-world"].runArtifacts(999).all();
-
-      assert.deepEqual(result, [{ id: 55, name: "build-output" }]);
-    });
-  });
-});

package/test/users.spec.ts

@@ -1,159 +0,0 @@
-// Import Node.js Dependencies
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-
-// Import Third-party Dependencies
-import { MockAgent, setGlobalDispatcher, getGlobalDispatcher, type Dispatcher } from "undici";
-
-// Import Internal Dependencies
-import { ApiEndpoint } from "../src/class/ApiEndpoint.ts";
-import { users, createUsersProxy } from "../src/api/users.ts";
-
-// CONSTANTS
-const kGithubOrigin = "https://api.github.com";
-const kUserEndpoints = ["orgs", "repos", "gists", "followers", "following", "starred"] as const;
-
-describe("Users API", () => {
-  let mockAgent: MockAgent;
-  let originalDispatcher: Dispatcher;
-
-  beforeEach(() => {
-    originalDispatcher = getGlobalDispatcher();
-    mockAgent = new MockAgent();
-    mockAgent.disableNetConnect();
-    setGlobalDispatcher(mockAgent);
-  });
-
-  afterEach(async() => {
-    await mockAgent.close();
-    setGlobalDispatcher(originalDispatcher);
-  });
-
-  describe("createUsersProxy()", () => {
-    it("should return an ApiEndpoint for each standard user endpoint", () => {
-      const proxy = createUsersProxy();
-
-      for (const endpoint of kUserEndpoints) {
-        const result = proxy.testuser[endpoint]();
-        assert.ok(result instanceof ApiEndpoint, `${endpoint}() should return an ApiEndpoint`);
-      }
-    });
-
-    it("should create independent ApiEndpoints per username", () => {
-      const proxy = createUsersProxy();
-
-      const fooOrgs = proxy.foo.orgs();
-      const barOrgs = proxy.bar.orgs();
-
-      assert.ok(fooOrgs instanceof ApiEndpoint);
-      assert.ok(barOrgs instanceof ApiEndpoint);
-      assert.notStrictEqual(fooOrgs, barOrgs);
-    });
-
-    it("should pass the token from config to the ApiEndpoint", async() => {
-      const proxy = createUsersProxy({ token: "mytoken" });
-
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({
-          path: "/users/testuser/repos",
-          method: "GET",
-          headers: { authorization: "token mytoken" }
-        })
-        .reply(200, JSON.stringify([]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      await assert.doesNotReject(proxy.testuser.repos().all());
-    });
-
-    it("should create a new ApiEndpoint on each method call", () => {
-      const proxy = createUsersProxy();
-
-      const first = proxy.testuser.repos();
-      const second = proxy.testuser.repos();
-
-      assert.notStrictEqual(first, second);
-    });
-  });
-
-  describe("users (default export)", () => {
-    it("should be a UsersProxy with no token", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/users/octocat/orgs", method: "GET" })
-        .reply(200, JSON.stringify([{ id: 1, login: "github" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await users.octocat.orgs().all();
-
-      assert.deepEqual(result, [{ id: 1, login: "github" }]);
-    });
-
-    it("should fetch repos for a user", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/users/octocat/repos", method: "GET" })
-        .reply(200, JSON.stringify([{ id: 42, name: "hello-world" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await users.octocat.repos().all();
-
-      assert.deepEqual(result, [{ id: 42, name: "hello-world" }]);
-    });
-
-    it("should fetch followers for a user", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/users/octocat/followers", method: "GET" })
-        .reply(200, JSON.stringify([{ login: "user1" }, { login: "user2" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await users.octocat.followers().all();
-
-      assert.deepEqual(result, [{ login: "user1" }, { login: "user2" }]);
-    });
-
-    it("should fetch following for a user", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/users/octocat/following", method: "GET" })
-        .reply(200, JSON.stringify([{ login: "user3" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await users.octocat.following().all();
-
-      assert.deepEqual(result, [{ login: "user3" }]);
-    });
-
-    it("should fetch gists for a user", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/users/octocat/gists", method: "GET" })
-        .reply(200, JSON.stringify([{ id: "abc123" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await users.octocat.gists().all();
-
-      assert.deepEqual(result, [{ id: "abc123" }]);
-    });
-
-    it("should fetch starred repos for a user", async() => {
-      mockAgent
-        .get(kGithubOrigin)
-        .intercept({ path: "/users/octocat/starred", method: "GET" })
-        .reply(200, JSON.stringify([{ id: 99, name: "starred-repo" }]), {
-          headers: { "content-type": "application/json" }
-        });
-
-      const result = await users.octocat.starred().all();
-
-      assert.deepEqual(result, [{ id: 99, name: "starred-repo" }]);
-    });
-  });
-});

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "@openally/config.typescript/esm-ts-next",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "./src",
-    "types": ["node"],
-    "lib": ["ES2022", "ES2023", "ES2024", "ESNext"],
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}