@adonisjs/content 1.3.0 → 1.5.0

package/build/src/loaders/main.js

@@ -1,229 +1,163 @@
+import {
+  aggregateInstalls,
+  aggregateStars,
+  createCache,
+  fetchAllSponsors,
+  fetchContributorsForOrg,
+  fetchReleases,
+  mergeArrays
+} from "../../chunk-WO5VTK7D.js";
 import {
   debug_default
 } from "../../chunk-LB6JFRVG.js";
 
-// src/loaders/gh_sponsors.ts
-import dayjs from "dayjs";
+// src/loaders/json.ts
 import vine from "@vinejs/vine";
 import { dirname } from "path";
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { readFile } from "fs/promises";
+var JsonLoader = class {
+  /** Path to the JSON file to load */
+  #source;
+  /**
+   * Creates a new JSON loader instance.
+   *
+   * @param source - Absolute or relative path to the JSON file
+   *
+   * @example
+   * ```ts
+   * const loader = new JsonLoader('./data/menu.json')
+   * ```
+   */
+  constructor(source) {
+    this.#source = source;
+  }
+  /**
+   * Loads and validates JSON data from the configured file.
+   * The directory of the source file is provided as metadata during validation.
+   *
+   * @param schema - VineJS schema to validate the loaded JSON data against
+   * @param metadata - Optional metadata to pass to the validator
+   *
+   * @example
+   * ```ts
+   * const data = await loader.load(menuSchema)
+   * ```
+   */
+  async load(schema, metadata) {
+    const menuFileRoot = dirname(this.#source);
+    const menu = JSON.parse(await readFile(this.#source, "utf-8"));
+    debug_default('loading file "%s"', this.#source);
+    return vine.validate({ schema, data: menu, meta: { menuFileRoot, ...metadata } });
+  }
+};
 
-// src/utils.ts
-import { Octokit } from "@octokit/rest";
-import { graphql } from "@octokit/graphql";
-async function fetchAllSponsors({
-  login,
-  isOrg,
-  ghToken
-}) {
-  let hasNext = true;
-  let cursor = null;
-  const allSponsors = [];
-  const query = `
-    query($login: String!, $cursor: String) {
-      ${isOrg ? `organization(login: $login)` : `user(login: $login)`} {
-        sponsorshipsAsMaintainer(first: 100, after: $cursor) {
-          nodes {
-            id
-            createdAt
-            privacyLevel
-            tier {
-              name
-              monthlyPriceInCents
-            }
-            sponsorEntity {
-              __typename
-              ... on User {
-                login
-                name
-                avatarUrl
-                url
-              }
-              ... on Organization {
-                login
-                name
-                avatarUrl
-                url
-              }
-            }
-          }
-          pageInfo {
-            hasNextPage
-            endCursor
-          }
-        }
-      }
-    }
-  `;
-  while (hasNext) {
-    const data = await graphql(query, {
-      headers: {
-        authorization: `token ${ghToken}`
-      },
-      login,
-      cursor
+// src/loaders/oss_stats.ts
+import vine2 from "@vinejs/vine";
+var OssStatsLoader = class {
+  /** Configuration options for the OSS stats loader */
+  #options;
+  /** Cache instance for storing and retrieving OSS stats data */
+  #cache;
+  /**
+   * Creates a new OSS stats loader instance.
+   *
+   * @param options - Configuration options for loading OSS statistics
+   *
+   * @example
+   * ```ts
+   * const loader = new OssStatsLoader({
+   *   outputPath: './cache/oss-stats.json',
+   *   refresh: 'weekly',
+   *   sources: [
+   *     {
+   *       type: 'github',
+   *       org: 'adonisjs',
+   *       ghToken: process.env.GITHUB_TOKEN
+   *     }
+   *   ]
+   * })
+   * ```
+   */
+  constructor(options) {
+    this.#options = options;
+    this.#cache = createCache({
+      key: "ossStats",
+      outputPath: options.outputPath,
+      refresh: options.refresh
     });
-    const root = isOrg ? data.organization : data.user;
-    if (!root) {
-      break;
-    }
-    const conn = root.sponsorshipsAsMaintainer;
-    if (!conn || !conn.nodes) {
-      break;
-    }
-    for (const node of conn.nodes) {
-      const sponsorEntity = node.sponsorEntity;
-      allSponsors.push({
-        id: node.id,
-        createdAt: node.createdAt,
-        privacyLevel: node.privacyLevel,
-        tierName: node.tier?.name ?? null,
-        tierMonthlyPriceInCents: node.tier?.monthlyPriceInCents ?? null,
-        sponsorType: sponsorEntity.__typename,
-        sponsorLogin: sponsorEntity.login,
-        sponsorName: sponsorEntity.name ?? null,
-        sponsorAvatarUrl: sponsorEntity.avatarUrl ?? null,
-        sponsorUrl: sponsorEntity.url ?? null
-      });
-    }
-    hasNext = conn.pageInfo.hasNextPage;
-    cursor = conn.pageInfo.endCursor;
   }
-  return allSponsors;
-}
-async function fetchReleases({
-  org,
-  ghToken,
-  filters
-}) {
-  let hasMoreRepos = true;
-  let orgCursor = null;
-  const allReleases = [];
-  while (hasMoreRepos) {
-    const query = `
-      query($cursor: String) {
-        organization(login: "${org}") {
-          repositories(
-            first: 10
-            after: $cursor
-            privacy: PUBLIC
-            isArchived: false
-          ) {
-            nodes {
-              name
-              releases(first: 50, orderBy: {field: CREATED_AT, direction: DESC}) {
-                nodes {
-                  name
-                  tagName
-                  publishedAt
-                  url
-                  description
-                }
-                pageInfo {
-                  endCursor
-                  hasNextPage
-                }
-              }
-            }
-            pageInfo {
-              endCursor
-              hasNextPage
-            }
-          }
-        }
+  /**
+   * Fetches and aggregates statistics from all configured sources.
+   * Processes GitHub and npm sources separately, then combines the results.
+   *
+   * @returns Aggregated statistics with total stars and installs
+   *
+   * @example
+   * ```ts
+   * const stats = await loader.fetchStats()
+   * console.log(`Total stars: ${stats.stars}`)
+   * console.log(`Total installs: ${stats.installs}`)
+   * ```
+   */
+  async #fetchStats() {
+    const aggregates = [];
+    for (const source of this.#options.sources) {
+      if (typeof source === "function") {
+        aggregates.push(await source());
+      } else if (source.type === "github") {
+        aggregates.push({
+          key: "stars",
+          count: await aggregateStars({
+            org: source.org,
+            ghToken: source.ghToken
+          })
+        });
+      } else if (source.type === "npm") {
+        aggregates.push({
+          key: "installs",
+          count: await aggregateInstalls(source.packages)
+        });
       }
-    `;
-    const data = await graphql(query, {
-      headers: {
-        authorization: `token ${ghToken}`
-      },
-      cursor: orgCursor
-    });
-    for (const repo of data.organization.repositories.nodes) {
-      const filtered = repo.releases.nodes.filter((r) => {
-        if (!filters) {
-          return true;
-        }
-        let pickRelease = true;
-        if (filters.nameDoesntInclude) {
-          pickRelease = !filters.nameDoesntInclude.some((substr) => r.name.includes(substr));
-        }
-        if (pickRelease && filters.nameIncludes) {
-          pickRelease = filters.nameIncludes.some((substr) => r.name.includes(substr));
-        }
-        return pickRelease;
-      }).map((r) => ({
-        repo: repo.name,
-        ...r
-      }));
-      allReleases.push(...filtered);
-    }
-    hasMoreRepos = data.organization.repositories.pageInfo.hasNextPage;
-    orgCursor = data.organization.repositories.pageInfo.endCursor;
-  }
-  return allReleases;
-}
-async function fetchContributorsForOrg({
-  org,
-  ghToken
-}) {
-  const REPO_PAGE_SIZE = 100;
-  const CONTRIB_PAGE_SIZE = 100;
-  const octokit = new Octokit({ auth: ghToken });
-  const repos = await octokit.paginate(octokit.repos.listForOrg, {
-    org,
-    type: "public",
-    per_page: REPO_PAGE_SIZE
-  });
-  const activeRepos = repos.filter((r) => !r.archived);
-  const result = [];
-  for (const repo of activeRepos) {
-    const repoName = repo.name;
-    try {
-      const contributors = await octokit.paginate(
-        octokit.repos.listContributors,
-        {
-          owner: org,
-          repo: repoName,
-          per_page: CONTRIB_PAGE_SIZE
-        },
-        (response) => response.data
-      );
-      contributors.forEach((c) => {
-        if (c.login) {
-          result.push({
-            login: c.login,
-            id: c.id,
-            avatar_url: c.avatar_url ?? null,
-            html_url: c.html_url ?? null,
-            contributions: c.contributions ?? 0
-          });
-        }
-      });
-    } catch (err) {
-      console.warn(
-        `Warning: failed to fetch contributors for ${org}/${repoName}: ${err?.message ?? err}`
-      );
     }
+    return aggregates.reduce((result, { key, count }) => {
+      result[key] = count;
+      return result;
+    }, {});
   }
-  return result;
-}
-function mergeArrays(existing, fresh, key) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [...existing];
-  for (const r of fresh) {
-    if (!seen.has(r[key])) {
-      seen.add(r[key]);
-      deduped.push(r);
+  /**
+   * Loads and validates OSS statistics data.
+   * Uses cached data if available and not expired, otherwise fetches fresh data
+   * from configured sources and updates the cache.
+   *
+   * @param schema - VineJS schema to validate the statistics data against
+   * @param metadata - Optional metadata to pass to the validator
+   *
+   * @example
+   * ```ts
+   * const stats = await loader.load(ossStatsSchema)
+   * ```
+   */
+  async load(schema, metadata) {
+    let stats = await this.#cache.get();
+    if (!stats) {
+      stats = await this.#fetchStats();
+      await this.#cache.put(stats);
     }
+    return vine2.validate({
+      schema,
+      data: stats,
+      meta: metadata
+    });
   }
-  return deduped;
-}
+};
 
 // src/loaders/gh_sponsors.ts
+import vine3 from "@vinejs/vine";
 var GithubSponsorsLoader = class {
   /** Configuration options for the GitHub sponsors loader */
   #options;
+  /** Cache instance for storing and retrieving sponsors data */
+  #cache;
   /**
    * Creates a new GitHub sponsors loader instance.
    *
@@ -242,54 +176,11 @@ var GithubSponsorsLoader = class {
    */
   constructor(options) {
     this.#options = options;
-  }
-  /**
-   * Loads previously cached sponsors from the output file.
-   * Returns an object containing lastFetched timestamp and sponsors array,
-   * or null if the file doesn't exist.
-   *
-   * @internal
-   */
-  async #loadExistingSponsors() {
-    try {
-      debug_default('loading existing sponsors file "%s"', this.#options.outputPath);
-      return JSON.parse(await readFile(this.#options.outputPath, "utf-8"));
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    return null;
-  }
-  /**
-   * Writes sponsors to the cache file with the current timestamp.
-   * Creates the output directory if it doesn't exist.
-   *
-   * @param sponsors - Array of GitHub sponsors to cache
-   * @internal
-   */
-  async #cacheSponsors(sponsors) {
-    debug_default('caching sponsors "%s"', this.#options.outputPath);
-    const fileContents = { lastFetched: (/* @__PURE__ */ new Date()).toISOString(), sponsors };
-    await mkdir(dirname(this.#options.outputPath), { recursive: true });
-    await writeFile(this.#options.outputPath, JSON.stringify(fileContents));
-    return fileContents;
-  }
-  /**
-   * Determines if the cached data has expired based on the refresh schedule.
-   *
-   * @param fetchDate - The date when data was last fetched
-   * @internal
-   */
-  #isExpired(fetchDate) {
-    switch (this.#options.refresh) {
-      case "daily":
-        return dayjs().isAfter(fetchDate, "day");
-      case "weekly":
-        return dayjs().isAfter(fetchDate, "week");
-      case "monthly":
-        return dayjs().isAfter(fetchDate, "month");
-    }
+    this.#cache = createCache({
+      key: "sponsors",
+      outputPath: options.outputPath,
+      refresh: options.refresh
+    });
   }
   /**
    * Loads and validates GitHub sponsors data.
@@ -305,28 +196,26 @@ var GithubSponsorsLoader = class {
    * ```
    */
   async load(schema, metadata) {
-    let existingSponsors = await this.#loadExistingSponsors();
-    if (!existingSponsors || this.#isExpired(new Date(existingSponsors.lastFetched))) {
-      debug_default('fetching sponsors from github "%s"', this.#options.login);
-      const sponsors = await fetchAllSponsors(this.#options);
-      existingSponsors = await this.#cacheSponsors(sponsors);
+    let sponsors = await this.#cache.get();
+    if (!sponsors) {
+      sponsors = await fetchAllSponsors(this.#options);
+      await this.#cache.put(sponsors);
     }
-    return vine.validate({
+    return vine3.validate({
       schema,
-      data: existingSponsors.sponsors,
+      data: sponsors,
       meta: metadata
     });
   }
 };
 
 // src/loaders/gh_releases.ts
-import dayjs2 from "dayjs";
-import vine2 from "@vinejs/vine";
-import { dirname as dirname2 } from "path";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import vine4 from "@vinejs/vine";
 var GithubReleasesLoader = class {
   /** Configuration options for the GitHub release loader */
   #options;
+  /** Cache instance for storing and retrieving releases data */
+  #cache;
   /**
    * Creates a new GitHub release loader instance.
    *
@@ -344,54 +233,11 @@ var GithubReleasesLoader = class {
    */
   constructor(options) {
     this.#options = options;
-  }
-  /**
-   * Loads previously cached releases from the output file.
-   * Returns an object containing lastFetched timestamp and releases array,
-   * or null if the file doesn't exist.
-   *
-   * @internal
-   */
-  async #loadExistingReleases() {
-    try {
-      debug_default('loading existing releases file "%s"', this.#options.outputPath);
-      return JSON.parse(await readFile2(this.#options.outputPath, "utf-8"));
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    return null;
-  }
-  /**
-   * Writes releases to the cache file with the current timestamp.
-   * Creates the output directory if it doesn't exist.
-   *
-   * @param releases - Array of GitHub releases to cache
-   * @internal
-   */
-  async #cacheReleases(releases) {
-    debug_default('caching releasing "%s"', this.#options.outputPath);
-    const fileContents = { lastFetched: (/* @__PURE__ */ new Date()).toISOString(), releases };
-    await mkdir2(dirname2(this.#options.outputPath), { recursive: true });
-    await writeFile2(this.#options.outputPath, JSON.stringify(fileContents));
-    return fileContents;
-  }
-  /**
-   * Determines if the cached data has expired based on the refresh schedule.
-   *
-   * @param fetchDate - The date when data was last fetched
-   * @internal
-   */
-  #isExpired(fetchDate) {
-    switch (this.#options.refresh) {
-      case "daily":
-        return dayjs2().isAfter(fetchDate, "day");
-      case "weekly":
-        return dayjs2().isAfter(fetchDate, "week");
-      case "monthly":
-        return dayjs2().isAfter(fetchDate, "month");
-    }
+    this.#cache = createCache({
+      key: "releases",
+      outputPath: options.outputPath,
+      refresh: options.refresh
+    });
   }
   /**
    * Loads and validates GitHub releases data.
@@ -407,29 +253,27 @@ var GithubReleasesLoader = class {
    * ```
    */
   async load(schema, metadata) {
-    let existingReleases = await this.#loadExistingReleases();
-    if (!existingReleases || this.#isExpired(new Date(existingReleases.lastFetched))) {
-      debug_default('fetching releases from github "%s"', this.#options.org);
-      const releases = await fetchReleases(this.#options);
-      const mergedReleases = existingReleases ? mergeArrays(existingReleases.releases, releases, "url") : releases;
-      existingReleases = await this.#cacheReleases(mergedReleases);
+    let cachedReleases = await this.#cache.get();
+    if (!cachedReleases) {
+      const freshReleases = await fetchReleases(this.#options);
+      const mergedReleases = cachedReleases ? mergeArrays(cachedReleases, freshReleases, "url") : freshReleases;
+      cachedReleases = await this.#cache.put(mergedReleases);
     }
-    return vine2.validate({
+    return vine4.validate({
       schema,
-      data: existingReleases.releases,
+      data: cachedReleases,
       meta: metadata
     });
   }
 };
 
 // src/loaders/gh_contributors.ts
-import dayjs3 from "dayjs";
-import vine3 from "@vinejs/vine";
-import { dirname as dirname3 } from "path";
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import vine5 from "@vinejs/vine";
 var GithubContributorsLoader = class {
   /** Configuration options for the GitHub contributors loader */
   #options;
+  /** Cache instance for storing and retrieving contributors data */
+  #cache;
   /**
    * Creates a new GitHub contributors loader instance.
    *
@@ -447,54 +291,11 @@ var GithubContributorsLoader = class {
    */
   constructor(options) {
     this.#options = options;
-  }
-  /**
-   * Loads previously cached contributors from the output file.
-   * Returns an object containing lastFetched timestamp and contributors array,
-   * or null if the file doesn't exist.
-   *
-   * @internal
-   */
-  async #loadExistingContributors() {
-    try {
-      debug_default('loading existing contributors file "%s"', this.#options.outputPath);
-      return JSON.parse(await readFile3(this.#options.outputPath, "utf-8"));
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    return null;
-  }
-  /**
-   * Writes contributors to the cache file with the current timestamp.
-   * Creates the output directory if it doesn't exist.
-   *
-   * @param contributors - Array of GitHub contributors to cache
-   * @internal
-   */
-  async #cacheContributors(contributors) {
-    debug_default('caching contributors "%s"', this.#options.outputPath);
-    const fileContents = { lastFetched: (/* @__PURE__ */ new Date()).toISOString(), contributors };
-    await mkdir3(dirname3(this.#options.outputPath), { recursive: true });
-    await writeFile3(this.#options.outputPath, JSON.stringify(fileContents));
-    return fileContents;
-  }
-  /**
-   * Determines if the cached data has expired based on the refresh schedule.
-   *
-   * @param fetchDate - The date when data was last fetched
-   * @internal
-   */
-  #isExpired(fetchDate) {
-    switch (this.#options.refresh) {
-      case "daily":
-        return dayjs3().isAfter(fetchDate, "day");
-      case "weekly":
-        return dayjs3().isAfter(fetchDate, "week");
-      case "monthly":
-        return dayjs3().isAfter(fetchDate, "month");
-    }
+    this.#cache = createCache({
+      key: "contributors",
+      outputPath: options.outputPath,
+      refresh: options.refresh
+    });
   }
   /**
    * Loads and validates GitHub contributors data.
@@ -510,60 +311,19 @@ var GithubContributorsLoader = class {
    * ```
    */
   async load(schema, metadata) {
-    let existingContributors = await this.#loadExistingContributors();
-    if (!existingContributors || this.#isExpired(new Date(existingContributors.lastFetched))) {
-      debug_default('fetching contributors from github "%s"', this.#options.org);
-      const contributors = await fetchContributorsForOrg(this.#options);
-      existingContributors = await this.#cacheContributors(contributors);
+    let contributors = await this.#cache.get();
+    if (!contributors) {
+      contributors = await fetchContributorsForOrg(this.#options);
+      await this.#cache.put(contributors);
     }
-    return vine3.validate({
+    return vine5.validate({
       schema,
-      data: existingContributors.contributors,
+      data: contributors,
       meta: metadata
     });
   }
 };
 
-// src/loaders/json.ts
-import vine4 from "@vinejs/vine";
-import { dirname as dirname4 } from "path";
-import { readFile as readFile4 } from "fs/promises";
-var JsonLoader = class {
-  /** Path to the JSON file to load */
-  #source;
-  /**
-   * Creates a new JSON loader instance.
-   *
-   * @param source - Absolute or relative path to the JSON file
-   *
-   * @example
-   * ```ts
-   * const loader = new JsonLoader('./data/menu.json')
-   * ```
-   */
-  constructor(source) {
-    this.#source = source;
-  }
-  /**
-   * Loads and validates JSON data from the configured file.
-   * The directory of the source file is provided as metadata during validation.
-   *
-   * @param schema - VineJS schema to validate the loaded JSON data against
-   * @param metadata - Optional metadata to pass to the validator
-   *
-   * @example
-   * ```ts
-   * const data = await loader.load(menuSchema)
-   * ```
-   */
-  async load(schema, metadata) {
-    const menuFileRoot = dirname4(this.#source);
-    const menu = JSON.parse(await readFile4(this.#source, "utf-8"));
-    debug_default('loading file "%s"', this.#source);
-    return vine4.validate({ schema, data: menu, meta: { menuFileRoot, ...metadata } });
-  }
-};
-
 // src/loaders/main.ts
 var loaders = {
   /**
@@ -624,6 +384,35 @@ var loaders = {
   ghReleases(options) {
     return new GithubReleasesLoader(options);
   },
+  /**
+   * Creates an OSS statistics loader instance.
+   *
+   * @param options - Configuration options for the OSS stats loader
+   *
+   * @example
+   * ```ts
+   * const loader = loaders.ossStats({
+   *   outputPath: './cache/oss-stats.json',
+   *   refresh: 'daily',
+   *   sources: [
+   *     {
+   *       type: 'github',
+   *       org: 'adonisjs',
+   *       ghToken: process.env.GITHUB_TOKEN
+   *     },
+   *     {
+   *       type: 'npm',
+   *       packages: [
+   *         { name: '@adonisjs/core', startDate: '2020-01-01' }
+   *       ]
+   *     }
+   *   ]
+   * })
+   * ```
+   */
+  ossStats(options) {
+    return new OssStatsLoader(options);
+  },
   /**
    * Creates a JSON file loader instance.
    *