@adonisjs/content 1.1.0

package/build/src/loaders/main.js

@@ -0,0 +1,648 @@
+import {
+  debug_default
+} from "../../chunk-LB6JFRVG.js";
+
+// src/loaders/gh_sponsors.ts
+import dayjs from "dayjs";
+import vine from "@vinejs/vine";
+import { dirname } from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+
+// 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
+    });
+    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
+            }
+          }
+        }
+      }
+    `;
+    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 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);
+    }
+  }
+  return deduped;
+}
+
+// src/loaders/gh_sponsors.ts
+var GithubSponsorsLoader = class {
+  /** Configuration options for the GitHub sponsors loader */
+  #options;
+  /**
+   * Creates a new GitHub sponsors loader instance.
+   *
+   * @param options - Configuration options for loading GitHub sponsors
+   * @param options.login - GitHub username or organization name
+   * @param options.isOrg - Whether the login is an organization (true) or user (false)
+   * @param options.ghToken - GitHub personal access token for authentication
+   * @param options.outputPath - Path where cached sponsors will be stored
+   * @param options.refresh - Refresh schedule: 'daily', 'weekly', or 'monthly'
+   *
+   * @example
+   * ```ts
+   * const loader = new GithubSponsorsLoader({
+   *   login: 'thetutlage',
+   *   isOrg: false,
+   *   ghToken: process.env.GITHUB_TOKEN,
+   *   outputPath: './cache/sponsors.json',
+   *   refresh: 'weekly'
+   * })
+   * ```
+   */
+  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");
+    }
+  }
+  /**
+   * Loads and validates GitHub sponsors data.
+   * Uses cached data if available and not expired, otherwise fetches fresh data
+   * from GitHub API and updates the cache.
+   *
+   * @param schema - VineJS schema to validate the sponsors data against
+   * @param metadata - Optional metadata to pass to the validator
+   *
+   * @example
+   * ```ts
+   * const sponsors = await loader.load(sponsorsSchema)
+   * ```
+   */
+  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);
+    }
+    return vine.validate({
+      schema,
+      data: existingSponsors.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";
+var GithubReleasesLoader = class {
+  /** Configuration options for the GitHub release loader */
+  #options;
+  /**
+   * Creates a new GitHub release loader instance.
+   *
+   * @param options - Configuration options for loading GitHub releases
+   *
+   * @example
+   * ```ts
+   * const loader = new GithubReleasesLoader({
+   *   org: 'adonisjs',
+   *   ghToken: process.env.GITHUB_TOKEN,
+   *   outputPath: './cache/releases.json',
+   *   refresh: 'weekly'
+   * })
+   * ```
+   */
+  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");
+    }
+  }
+  /**
+   * Loads and validates GitHub releases data.
+   * Uses cached data if available and not expired, otherwise fetches fresh data
+   * from GitHub API and merges with existing releases.
+   *
+   * @param schema - VineJS schema to validate the releases data against
+   * @param metadata - Optional metadata to pass to the validator
+   *
+   * @example
+   * ```ts
+   * const releases = await loader.load(releasesSchema)
+   * ```
+   */
+  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);
+    }
+    return vine2.validate({
+      schema,
+      data: existingReleases.releases,
+      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";
+var GithubContributorsLoader = class {
+  /** Configuration options for the GitHub contributors loader */
+  #options;
+  /**
+   * Creates a new GitHub contributors loader instance.
+   *
+   * @param options - Configuration options for loading GitHub contributors
+   *
+   * @example
+   * ```ts
+   * const loader = new GithubContributorsLoader({
+   *   org: 'adonisjs',
+   *   ghToken: process.env.GITHUB_TOKEN,
+   *   outputPath: './cache/contributors.json',
+   *   refresh: 'weekly'
+   * })
+   * ```
+   */
+  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");
+    }
+  }
+  /**
+   * Loads and validates GitHub contributors data.
+   * Uses cached data if available and not expired, otherwise fetches fresh data
+   * from GitHub API and updates the cache.
+   *
+   * @param schema - VineJS schema to validate the contributors data against
+   * @param metadata - Optional metadata to pass to the validator
+   *
+   * @example
+   * ```ts
+   * const contributors = await loader.load(contributorsSchema)
+   * ```
+   */
+  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);
+    }
+    return vine3.validate({
+      schema,
+      data: existingContributors.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 = {
+  /**
+   * Creates a GitHub sponsors loader instance.
+   *
+   * @param options - Configuration options for the sponsors loader
+   *
+   * @example
+   * ```ts
+   * const loader = loaders.ghSponsors({
+   *   login: 'adonisjs',
+   *   isOrg: true,
+   *   ghToken: process.env.GITHUB_TOKEN,
+   *   outputPath: './cache/sponsors.json',
+   *   refresh: 'daily'
+   * })
+   * ```
+   */
+  ghSponsors(options) {
+    return new GithubSponsorsLoader(options);
+  },
+  /**
+   * Creates a GitHub contributors loader instance.
+   *
+   * @param options - Configuration options for the contributors loader
+   *
+   * @example
+   * ```ts
+   * const loader = loaders.ghContributors({
+   *   org: 'adonisjs',
+   *   ghToken: process.env.GITHUB_TOKEN,
+   *   outputPath: './cache/contributors.json',
+   *   refresh: 'weekly'
+   * })
+   * ```
+   */
+  ghContributors(options) {
+    return new GithubContributorsLoader(options);
+  },
+  /**
+   * Creates a GitHub releases loader instance.
+   *
+   * @param options - Configuration options for the releases loader
+   *
+   * @example
+   * ```ts
+   * const loader = loaders.ghReleases({
+   *   org: 'adonisjs',
+   *   ghToken: process.env.GITHUB_TOKEN,
+   *   outputPath: './cache/releases.json',
+   *   refresh: 'daily',
+   *   filters: {
+   *     nameDoesntInclude: ['alpha', 'beta']
+   *   }
+   * })
+   * ```
+   */
+  ghReleases(options) {
+    return new GithubReleasesLoader(options);
+  },
+  /**
+   * Creates a JSON file loader instance.
+   *
+   * @param source - Path to the JSON file to load
+   *
+   * @example
+   * ```ts
+   * const loader = loaders.jsonLoader('./data/menu.json')
+   * ```
+   */
+  jsonLoader(source) {
+    return new JsonLoader(source);
+  }
+};
+export {
+  loaders
+};