anilink-api-wrapper 1.0.0 → 1.2.0

package/dist/apis/anilist/query/User.js

@@ -8,21 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserQuery = void 0;
 const APIWrapper_1 = require("../../../base/APIWrapper");
 const RequestHandler_1 = require("../../../base/RequestHandler");
+const User_1 = require("../interfaces/responses/User");
 class UserQuery extends APIWrapper_1.APIWrapper {
     constructor(authToken) {
         super('https://graphql.anilist.co');
@@ -30,542 +20,14 @@ class UserQuery extends APIWrapper_1.APIWrapper {
     }
     user(variables) {
         return __awaiter(this, void 0, void 0, function* () {
-            // If isHTML is not provided in variables, default it to true
-            const _a = variables != null ? variables : {}, { isHTML = true } = _a, rest = __rest(_a, ["isHTML"]);
             const query = `
-          query ($id: Int, $name: String, $isModerator: Boolean, $search: String, $sort: [UserSort], $isHTML: Boolean, $animeStatLimit: Int, $mangaStatLimit: Int, $animeStatSort: [UserStatisticsSort], $mangaStatSort: [UserStatisticsSort]) {
-            User (id: $id, name: $name, isModerator: $isModerator, search: $search, sort: $sort) {
-              id
-              name
-              about(asHtml: $isHTML)
-              avatar {
-                large
-                medium
-              }
-              bannerImage
-              isFollowing
-              isFollower
-              isBlocked
-              bans
-              options {
-                  titleLanguage
-                  displayAdultContent
-                  airingNotifications
-                  profileColor
-                  notificationOptions {
-                    type
-                    enabled
-                  }
-                  timezone
-                  activityMergeTime
-                  staffNameLanguage
-                  restrictMessagesToFollowing
-                  disabledListActivity {
-                  disabled
-                  type
-                  }
-              }
-              mediaListOptions {
-                scoreFormat
-                rowOrder
-                animeList {
-                  sectionOrder
-                  splitCompletedSectionByFormat
-                  customLists
-                  advancedScoring
-                  advancedScoringEnabled
-                }
-                mangaList {
-                  sectionOrder
-                  splitCompletedSectionByFormat
-                  customLists
-                  advancedScoring
-                  advancedScoringEnabled
-                }
-              }
-              favourites {
-                anime (perPage: 50) {
-                  edges {
-                    node {
-                      id
-                      title {
-                        romaji
-                        english
-                        native
-                        userPreferred
-                      }
-                    }
-                  }
-                  nodes {
-                    id
-                    title {
-                      romaji
-                      english
-                      native
-                      userPreferred
-                    }
-                  }
-                }
-                manga (perPage: 50) {
-                  edges {
-                    node {
-                    id
-                    title {
-                      romaji
-                      english
-                      native
-                      userPreferred
-                      }
-                    }
-                  }
-                  nodes {
-                    id
-                    title {
-                      romaji
-                      english
-                      native
-                      userPreferred
-                    }
-                  }
-                }
-                characters (perPage: 50) {
-                  edges {
-                    id
-                    role
-                    name
-                    voiceActors {
-                      id
-                      name {
-                        first
-                        last
-                        full
-                        native
-                      }
-                      image {
-                        large
-                      }
-                    }
-                    media {
-                      id
-                      title {
-                        romaji
-                        english
-                        native
-                        userPreferred
-                      }
-                      coverImage {
-                        extraLarge
-                        large
-                        medium
-                        color
-                      }
-                    }
-                    favouriteOrder
-                    node {
-                      id
-                      name {
-                        first
-                        last
-                        full
-                        native
-                      }
-                      image {
-                        large
-                      }
-                    }
-                  }
-                }
-                staff (perPage: 50) {
-                  edges {
-                    id
-                    role
-                    favouriteOrder
-                    node {
-                      id
-                      name {
-                        first
-                        last
-                        full
-                        native
-                      }
-                      image {
-                        large
-                      }
-                    }
-                  }
-                }
-                studios (perPage: 50) {
-                  edges {
-                    id
-                    isMain
-                    favouriteOrder
-                    node {
-                      id
-                      name
-                      isAnimationStudio
-                      siteUrl
-                    }
-                  }
-                }
-              }
-              statistics {
-                anime {
-                  count
-                  meanScore
-                  standardDeviation
-                  minutesWatched
-                  episodesWatched
-                  formats (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    format
-                  }
-                  statuses (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    status
-                  }
-                  scores (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    score
-                  }
-                  lengths (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    length
-                  }
-                  releaseYears (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    releaseYear
-                  }
-                  startYears (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    startYear
-                  }
-                  genres (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    genre
-                  }
-                  tags (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    tag {
-                      id
-                      name
-                      description
-                      category
-                      rank
-                      isGeneralSpoiler
-                      isMediaSpoiler
-                      isAdult
-                    }
-                  }
-                  countries (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    country
-                  }
-                  voiceActors (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    voiceActor {
-                      id
-                      name {
-                        first
-                        last
-                        full
-                        native
-                        alternative
-                        userPreferred
-                      }
-                    }
-                    characterIds
-                  }
-                  staff (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    staff {
-                      id
-                      name {
-                        first
-                        last
-                        full
-                        native
-                        alternative
-                        userPreferred
-                      }
-                    }
-                  }
-                  studios (limit: $animeStatLimit, sort: $animeStatSort) {
-                    count
-                    meanScore
-                    minutesWatched
-                    mediaIds
-                    studio {
-                      id
-                      name
-                    }
-                  }
-                }
-                manga {
-                  count
-                  meanScore
-                  standardDeviation
-                  chaptersRead
-                  volumesRead
-                  formats (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    format
-                  }
-                  statuses (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    status
-                  }
-                  scores (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    score
-                  }
-                  lengths (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    length
-                  }
-                  releaseYears (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    releaseYear
-                  }
-                  startYears (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    startYear
-                  }
-                  genres (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    genre
-                  }
-                  tags (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    tag {
-                      id
-                      name
-                      description
-                      category
-                      rank
-                      isGeneralSpoiler
-                      isMediaSpoiler
-                      isAdult
-                    }
-                  }
-                  countries (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    country
-                  }
-                  staff (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    staff {
-                      id
-                      name {
-                        first
-                        last
-                        full
-                        native
-                        alternative
-                        userPreferred
-                      }
-                    }
-                  }
-                  studios (limit: $mangaStatLimit, sort: $mangaStatSort) {
-                    count
-                    meanScore
-                    chaptersRead
-                    mediaIds
-                    studio {
-                      id
-                      name
-                    }
-                  }
-                }
-              }
-              stats {
-                watchedTime
-                chaptersRead
-                activityHistory {
-                  date
-                  amount
-                  level
-                }
-                animeStatusDistribution {
-                  status
-                  amount
-                }
-                mangaStatusDistribution {
-                  status
-                  amount
-                }
-                animeScoreDistribution {
-                  score
-                  amount
-                }
-                mangaScoreDistribution {
-                  score
-                  amount
-                }
-                animeListScores {
-                  meanScore
-                  standardDeviation
-                }
-                mangaListScores {
-                  meanScore
-                  standardDeviation
-                }
-                favouredGenresOverview {
-                  genre
-                  amount
-                  meanScore
-                  timeWatched
-                }
-                favouredGenres {
-                  genre
-                  amount
-                  meanScore
-                  timeWatched
-                }
-                favouredTags {
-                  tag {
-                    id
-                    name
-                    description
-                    category
-                    rank
-                    isGeneralSpoiler
-                    isMediaSpoiler
-                    isAdult
-                  }
-                  amount
-                  meanScore
-                  timeWatched
-                }
-                favouredActors {
-                  staff {
-                    id
-                    name {
-                      first
-                      last
-                      full
-                      native
-                      alternative
-                      userPreferred
-                    }
-                  }
-                  amount
-                  meanScore
-                  timeWatched
-                }
-                favouredStaff {
-                  staff {
-                    id
-                    name {
-                      first
-                      last
-                      full
-                      native
-                      alternative
-                      userPreferred
-                    }
-                  }
-                  amount
-                  meanScore
-                  timeWatched
-                }
-                favouredStudios {
-                  studio {
-                    id
-                    name
-                  }
-                  amount
-                  meanScore
-                  timeWatched
-                }
-                favouredYears {
-                  year
-                  amount
-                  meanScore
-                }
-                favouredFormats {
-                  format
-                  amount
-                }
-              }
-              unreadNotificationCount
-              siteUrl
-              donatorTier
-              donatorBadge
-              moderatorRoles
-              createdAt
-              updatedAt
-              previousNames {
-                name
-                createdAt
-                updatedAt
-              }
-            }
-          }
-        `;
-            const data = { query, variables: Object.assign({ isHTML }, rest) };
+      query ($id: Int, $name: String, $isModerator: Boolean, $search: String, $sort: [UserSort], $asHtml: Boolean, $animeStatLimit: Int, $mangaStatLimit: Int, $animeStatSort: [UserStatisticsSort], $mangaStatSort: [UserStatisticsSort]) {
+        User (id: $id, name: $name, isModerator: $isModerator, search: $search, sort: $sort) {
+          ${User_1.UserSchema}
+        }
+      }
+    `;
+            const data = { query, variables };
             return yield (0, RequestHandler_1.sendRequest)(this.baseURL, 'POST', data, this.authToken);
         });
     }

package/dist/apis/anilist/query/Viewer.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewerQuery = void 0;
+const APIWrapper_1 = require("../../../base/APIWrapper");
+const RequestHandler_1 = require("../../../base/RequestHandler");
+const User_1 = require("../interfaces/responses/User");
+class ViewerQuery extends APIWrapper_1.APIWrapper {
+    constructor(authToken) {
+        super('https://graphql.anilist.co');
+        this.authToken = authToken;
+    }
+    viewer(variables) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `
+      query ($asHtml: Boolean, $animeStatLimit: Int, $mangaStatLimit: Int, $animeStatSort: [UserStatisticsSort], $mangaStatSort: [UserStatisticsSort]) {
+        Viewer {
+          ${User_1.UserSchema}
+        }
+      }
+    `;
+            const data = { query, variables };
+            return yield (0, RequestHandler_1.sendRequest)(this.baseURL, 'POST', data, this.authToken);
+        });
+    }
+}
+exports.ViewerQuery = ViewerQuery;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "anilink-api-wrapper",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Anilist API Wrapper",
   "main": "dist/AniLink.js",
   "scripts": {
     "test": "jest",
-    "build": "tsc"
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "anilist",

package/.eslintignore

@@ -1 +0,0 @@
-/__tests__/*

package/.github/workflows/code_quality.yml

@@ -1,32 +0,0 @@
----
-name: Qodana
-on:
-  workflow_dispatch:
-  pull_request:
-  push:
-    branches:
-      - master
-      - 'releases/*'
-
-jobs:
-  qodana:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: write
-      checks: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          fetch-depth: 0
-      - name: Setup Node.js environment
-        uses: actions/setup-node@v4.0.2
-        with:
-          node-version: '21'
-          cache: 'npm'
-      - run: npm ci
-      - name: 'Qodana Scan'
-        uses: JetBrains/qodana-action@v2023.3.1
-        env:
-          QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}

package/.github/workflows/codeql.yml

@@ -1,33 +0,0 @@
----
-name: "CodeQL"
-on:
-  push:
-    branches: ["master"]
-  pull_request:
-    branches: ["master"]
-  schedule:
-    - cron: '0 7 * * 1'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write
-      actions: read
-      contents: read
-    strategy:
-      fail-fast: false
-      matrix:
-        language: ['javascript-typescript']
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
-        with:
-          languages: ${{ matrix.language }}
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
-        with:
-          category: "/language:${{matrix.language}}"