decap-cms-backend-gitea 3.0.4

package/src/implementation.tsx

@@ -0,0 +1,450 @@
+import { stripIndent } from 'common-tags';
+import trimStart from 'lodash/trimStart';
+import semaphore from 'semaphore';
+import {
+  asyncLock,
+  basename,
+  blobToFileObj,
+  Cursor,
+  CURSOR_COMPATIBILITY_SYMBOL,
+  entriesByFiles,
+  entriesByFolder,
+  filterByExtension,
+  getBlobSHA,
+  getMediaAsBlob,
+  getMediaDisplayURL,
+  runWithLock,
+  unsentRequest,
+} from 'decap-cms-lib-util';
+
+import API, { API_NAME } from './API';
+import AuthenticationPage from './AuthenticationPage';
+
+import type {
+  AssetProxy,
+  AsyncLock,
+  Config,
+  Credentials,
+  DisplayURL,
+  Entry,
+  Implementation,
+  ImplementationFile,
+  PersistOptions,
+  User,
+} from 'decap-cms-lib-util';
+import type { Semaphore } from 'semaphore';
+import type { GiteaUser } from './types';
+
+const MAX_CONCURRENT_DOWNLOADS = 10;
+
+type ApiFile = { id: string; type: string; name: string; path: string; size: number };
+
+const { fetchWithTimeout: fetch } = unsentRequest;
+
+export default class Gitea implements Implementation {
+  lock: AsyncLock;
+  api: API | null;
+  options: {
+    proxied: boolean;
+    API: API | null;
+    useWorkflow?: boolean;
+  };
+  originRepo: string;
+  repo?: string;
+  branch: string;
+  apiRoot: string;
+  mediaFolder?: string;
+  token: string | null;
+  _currentUserPromise?: Promise<GiteaUser>;
+  _userIsOriginMaintainerPromises?: {
+    [key: string]: Promise<boolean>;
+  };
+  _mediaDisplayURLSem?: Semaphore;
+
+  constructor(config: Config, options = {}) {
+    this.options = {
+      proxied: false,
+      API: null,
+      useWorkflow: false,
+      ...options,
+    };
+
+    if (
+      !this.options.proxied &&
+      (config.backend.repo === null || config.backend.repo === undefined)
+    ) {
+      throw new Error('The Gitea backend needs a "repo" in the backend configuration.');
+    }
+
+    if (this.options.useWorkflow) {
+      throw new Error('The Gitea backend does not support editorial workflow.');
+    }
+
+    this.api = this.options.API || null;
+    this.repo = this.originRepo = config.backend.repo || '';
+    this.branch = config.backend.branch?.trim() || 'master';
+    this.apiRoot = config.backend.api_root || 'https://try.gitea.io/api/v1';
+    this.token = '';
+    this.mediaFolder = config.media_folder;
+    this.lock = asyncLock();
+  }
+
+  isGitBackend() {
+    return true;
+  }
+
+  async status() {
+    const auth =
+      (await this.api
+        ?.user()
+        .then(user => !!user)
+        .catch(e => {
+          console.warn('[StaticCMS] Failed getting Gitea user', e);
+          return false;
+        })) || false;
+
+    return { auth: { status: auth }, api: { status: true, statusPage: '' } };
+  }
+
+  authComponent() {
+    return AuthenticationPage;
+  }
+
+  restoreUser(user: User) {
+    return this.authenticate(user);
+  }
+
+  async currentUser({ token }: { token: string }) {
+    if (!this._currentUserPromise) {
+      this._currentUserPromise = fetch(`${this.apiRoot}/user`, {
+        headers: {
+          Authorization: `token ${token}`,
+        },
+      }).then(res => res.json());
+    }
+    return this._currentUserPromise;
+  }
+
+  async userIsOriginMaintainer({
+    username: usernameArg,
+    token,
+  }: {
+    username?: string;
+    token: string;
+  }) {
+    const username = usernameArg || (await this.currentUser({ token })).login;
+    this._userIsOriginMaintainerPromises = this._userIsOriginMaintainerPromises || {};
+    if (!this._userIsOriginMaintainerPromises[username]) {
+      this._userIsOriginMaintainerPromises[username] = fetch(
+        `${this.apiRoot}/repos/${this.originRepo}/collaborators/${username}/permission`,
+        {
+          headers: {
+            Authorization: `token ${token}`,
+          },
+        },
+      )
+        .then(res => res.json())
+        .then(({ permission }) => permission === 'admin' || permission === 'write');
+    }
+    return this._userIsOriginMaintainerPromises[username];
+  }
+
+  async authenticate(state: Credentials) {
+    this.token = state.token as string;
+    const apiCtor = API;
+    this.api = new apiCtor({
+      token: this.token,
+      branch: this.branch,
+      repo: this.repo,
+      originRepo: this.originRepo,
+      apiRoot: this.apiRoot,
+    });
+    const user = await this.api!.user();
+    const isCollab = await this.api!.hasWriteAccess().catch(error => {
+      error.message = stripIndent`
+        Repo "${this.repo}" not found.
+
+        Please ensure the repo information is spelled correctly.
+
+        If the repo is private, make sure you're logged into a Gitea account with access.
+
+        If your repo is under an organization, ensure the organization has granted access to Static
+        CMS.
+      `;
+      throw error;
+    });
+
+    // Unauthorized user
+    if (!isCollab) {
+      throw new Error('Your Gitea user account does not have access to this repo.');
+    }
+
+    // Authorized user
+    return {
+      name: user.full_name,
+      login: user.login,
+      avatar_url: user.avatar_url,
+      token: state.token as string,
+    };
+  }
+
+  logout() {
+    this.token = null;
+    if (this.api && this.api.reset && typeof this.api.reset === 'function') {
+      return this.api.reset();
+    }
+  }
+
+  getToken() {
+    return Promise.resolve(this.token);
+  }
+
+  getCursorAndFiles = (files: ApiFile[], page: number) => {
+    const pageSize = 20;
+    const count = files.length;
+    const pageCount = Math.ceil(files.length / pageSize);
+
+    const actions = [] as string[];
+    if (page > 1) {
+      actions.push('prev');
+      actions.push('first');
+    }
+    if (page < pageCount) {
+      actions.push('next');
+      actions.push('last');
+    }
+
+    const cursor = Cursor.create({
+      actions,
+      meta: { page, count, pageSize, pageCount },
+      data: { files },
+    });
+    const pageFiles = files.slice((page - 1) * pageSize, page * pageSize);
+    return { cursor, files: pageFiles };
+  };
+
+  async entriesByFolder(folder: string, extension: string, depth: number) {
+    const repoURL = this.api!.originRepoURL;
+
+    let cursor: Cursor;
+
+    const listFiles = () =>
+      this.api!.listFiles(folder, {
+        repoURL,
+        depth,
+      }).then(files => {
+        const filtered = files.filter(file => filterByExtension(file, extension));
+        const result = this.getCursorAndFiles(filtered, 1);
+        cursor = result.cursor;
+        return result.files;
+      });
+
+    const readFile = (path: string, id: string | null | undefined) =>
+      this.api!.readFile(path, id, { repoURL }) as Promise<string>;
+
+    const files = await entriesByFolder(
+      listFiles,
+      readFile,
+      this.api!.readFileMetadata.bind(this.api),
+      API_NAME,
+    );
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    files[CURSOR_COMPATIBILITY_SYMBOL] = cursor;
+    return files;
+  }
+
+  async allEntriesByFolder(folder: string, extension: string, depth: number) {
+    const repoURL = this.api!.originRepoURL;
+
+    const listFiles = () =>
+      this.api!.listFiles(folder, {
+        repoURL,
+        depth,
+      }).then(files => files.filter(file => filterByExtension(file, extension)));
+
+    const readFile = (path: string, id: string | null | undefined) => {
+      return this.api!.readFile(path, id, { repoURL }) as Promise<string>;
+    };
+
+    const files = await entriesByFolder(
+      listFiles,
+      readFile,
+      this.api!.readFileMetadata.bind(this.api),
+      API_NAME,
+    );
+    return files;
+  }
+
+  entriesByFiles(files: ImplementationFile[]) {
+    const repoURL = this.api!.repoURL;
+
+    const readFile = (path: string, id: string | null | undefined) =>
+      this.api!.readFile(path, id, { repoURL }).catch(() => '') as Promise<string>;
+
+    return entriesByFiles(files, readFile, this.api!.readFileMetadata.bind(this.api), API_NAME);
+  }
+
+  // Fetches a single entry.
+  getEntry(path: string) {
+    const repoURL = this.api!.originRepoURL;
+    return this.api!.readFile(path, null, { repoURL })
+      .then(data => ({
+        file: { path, id: null },
+        data: data as string,
+      }))
+      .catch(() => ({ file: { path, id: null }, data: '' }));
+  }
+
+  async getMedia(mediaFolder = this.mediaFolder, folderSupport?: boolean) {
+    if (!mediaFolder) {
+      return [];
+    }
+    return this.api!.listFiles(mediaFolder, undefined, folderSupport).then(files =>
+      files.map(({ id, name, size, path, type }) => {
+        return { id, name, size, displayURL: { id, path }, path, isDirectory: type === 'tree' };
+      }),
+    );
+  }
+
+  async getMediaFile(path: string) {
+    const blob = await getMediaAsBlob(path, null, this.api!.readFile.bind(this.api!));
+
+    const name = basename(path);
+    const fileObj = blobToFileObj(name, blob);
+    const url = URL.createObjectURL(fileObj);
+    const id = await getBlobSHA(blob);
+
+    return {
+      id,
+      displayURL: url,
+      path,
+      name,
+      size: fileObj.size,
+      file: fileObj,
+      url,
+    };
+  }
+
+  getMediaDisplayURL(displayURL: DisplayURL) {
+    this._mediaDisplayURLSem = this._mediaDisplayURLSem || semaphore(MAX_CONCURRENT_DOWNLOADS);
+    return getMediaDisplayURL(
+      displayURL,
+      this.api!.readFile.bind(this.api!),
+      this._mediaDisplayURLSem,
+    );
+  }
+
+  persistEntry(entry: Entry, options: PersistOptions) {
+    // persistEntry is a transactional operation
+    return runWithLock(
+      this.lock,
+      () => this.api!.persistFiles(entry.dataFiles, entry.assets, options),
+      'Failed to acquire persist entry lock',
+    );
+  }
+
+  async persistMedia(mediaFile: AssetProxy, options: PersistOptions) {
+    try {
+      await this.api!.persistFiles([], [mediaFile], options);
+      const { sha, path, fileObj } = mediaFile as AssetProxy & { sha: string };
+      const displayURL = URL.createObjectURL(fileObj as Blob);
+      return {
+        id: sha,
+        name: fileObj!.name,
+        size: fileObj!.size,
+        displayURL,
+        path: trimStart(path, '/'),
+      };
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+
+  deleteFiles(paths: string[], commitMessage: string) {
+    return this.api!.deleteFiles(paths, commitMessage);
+  }
+
+  async traverseCursor(cursor: Cursor, action: string) {
+    const meta = cursor.meta!;
+    const files = cursor.data!.get('files')!.toJS() as ApiFile[];
+
+    let result: { cursor: Cursor; files: ApiFile[] };
+    switch (action) {
+      case 'first': {
+        result = this.getCursorAndFiles(files, 1);
+        break;
+      }
+      case 'last': {
+        result = this.getCursorAndFiles(files, meta.get('pageCount'));
+        break;
+      }
+      case 'next': {
+        result = this.getCursorAndFiles(files, meta.get('page') + 1);
+        break;
+      }
+      case 'prev': {
+        result = this.getCursorAndFiles(files, meta.get('page') - 1);
+        break;
+      }
+      default: {
+        result = this.getCursorAndFiles(files, 1);
+        break;
+      }
+    }
+
+    const readFile = (path: string, id: string | null | undefined) =>
+      this.api!.readFile(path, id, { repoURL: this.api!.originRepoURL }).catch(
+        () => '',
+      ) as Promise<string>;
+
+    const entries = await entriesByFiles(
+      result.files,
+      readFile,
+      this.api!.readFileMetadata.bind(this.api),
+      API_NAME,
+    );
+
+    return {
+      entries,
+      cursor: result.cursor,
+    };
+  }
+
+  async unpublishedEntries() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return {} as any;
+  }
+
+  async unpublishedEntry() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return {} as any;
+  }
+
+  async unpublishedEntryDataFile() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return {} as any;
+  }
+
+  async unpublishedEntryMediaFile() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return {} as any;
+  }
+
+  async updateUnpublishedEntryStatus() {
+    return;
+  }
+
+  async publishUnpublishedEntry() {
+    return;
+  }
+  async deleteUnpublishedEntry() {
+    return;
+  }
+
+  async getDeployPreview() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return {} as any;
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { default as GiteaBackend } from './implementation';
+export { default as API } from './API';
+export { default as AuthenticationPage } from './AuthenticationPage';

package/src/types.ts

@@ -0,0 +1,260 @@
+export type GiteaUser = {
+  active: boolean;
+  avatar_url: string;
+  created: string;
+  description: string;
+  email: string;
+  followers_count: number;
+  following_count: number;
+  full_name: string;
+  id: number;
+  is_admin: boolean;
+  language: string;
+  last_login: string;
+  location: string;
+  login: string;
+  login_name?: string;
+  prohibit_login: boolean;
+  restricted: boolean;
+  starred_repos_count: number;
+  visibility: string;
+  website: string;
+};
+
+export type GiteaTeam = {
+  can_create_org_repo: boolean;
+  description: string;
+  id: number;
+  includes_all_repositories: boolean;
+  name: string;
+  organization: GiteaOrganization;
+  permission: string;
+  units: Array<string>;
+  units_map: Map<string, string>;
+};
+
+export type GiteaOrganization = {
+  avatar_url: string;
+  description: string;
+  full_name: string;
+  id: number;
+  location: string;
+  name: string;
+  repo_admin_change_team_access: boolean;
+  username: string;
+  visibility: string;
+  website: string;
+};
+
+type CommitUser = {
+  date: string;
+  email: string;
+  name: string;
+};
+
+type CommitMeta = {
+  created: string;
+  sha: string;
+  url: string;
+};
+
+type PayloadUser = {
+  email: string;
+  name: string;
+  username: string;
+};
+
+type PayloadCommitVerification = {
+  payload: string;
+  reason: string;
+  signature: string;
+  signer: PayloadUser;
+  verified: boolean;
+};
+
+type ReposListCommitsResponseItemCommit = {
+  author: CommitUser;
+  committer: CommitUser;
+  message: string;
+  tree: CommitMeta;
+  url: string;
+  verification: PayloadCommitVerification;
+};
+
+type GiteaRepositoryPermissions = {
+  admin: boolean;
+  pull: boolean;
+  push: boolean;
+};
+
+type GiteaRepositoryExternalTracker = {
+  external_tracker_format: string;
+  external_tracker_regexp_pattern: string;
+  external_tracker_style: string;
+  external_tracker_url: string;
+};
+
+type GiteaRepositoryExternalWiki = {
+  external_wiki_url: string;
+};
+
+type GiteaRepositoryInternalTracker = {
+  allow_only_contributors_to_track_time: boolean;
+  enable_issue_dependencies: boolean;
+  enable_time_tracker: boolean;
+};
+
+type GiteaRepositoryRepoTransfer = {
+  description: string;
+  doer: GiteaUser;
+  recipient: GiteaUser;
+  teams: Array<GiteaTeam>;
+  enable_issue_dependencies: boolean;
+  enable_time_tracker: boolean;
+};
+
+export type GiteaRepository = {
+  allow_merge_commits: boolean;
+  allow_rebase: boolean;
+  allow_rebase_explicit: boolean;
+  allow_rebase_update: boolean;
+  allow_squash_merge: boolean;
+  archived: boolean;
+  avatar_url: string;
+  clone_url: string;
+  created_at: string;
+  default_branch: string;
+  default_delete_branch_after_merge: boolean;
+  default_merge_style: boolean;
+  description: string;
+  empty: boolean;
+  external_tracker: GiteaRepositoryExternalTracker;
+  external_wiki: GiteaRepositoryExternalWiki;
+  fork: boolean;
+  forks_count: number;
+  full_name: string;
+  has_issues: boolean;
+  has_projects: boolean;
+  has_pull_requests: boolean;
+  has_wiki: boolean;
+  html_url: string;
+  id: number;
+  ignore_whitespace_conflicts: boolean;
+  internal: boolean;
+  internal_tracker: GiteaRepositoryInternalTracker;
+  language: string;
+  languages_url: string;
+  mirror: boolean;
+  mirror_interval: string;
+  mirror_updated: string;
+  name: string;
+  open_issues_count: number;
+  open_pr_counter: number;
+  original_url: string;
+  owner: GiteaUser;
+  parent: null;
+  permissions: GiteaRepositoryPermissions;
+  private: boolean;
+  release_counter: number;
+  repo_transfer: GiteaRepositoryRepoTransfer;
+  size: number;
+  ssh_url: string;
+  stars_count: number;
+  template: boolean;
+  updated_at: string;
+  watchers_count: number;
+  website: string;
+};
+
+type ReposListCommitsResponseItemCommitAffectedFiles = {
+  filename: string;
+};
+
+type ReposListCommitsResponseItemCommitStats = {
+  additions: number;
+  deletions: number;
+  total: number;
+};
+
+type ReposListCommitsResponseItem = {
+  author: GiteaUser;
+  commit: ReposListCommitsResponseItemCommit;
+  committer: GiteaUser;
+  created: string;
+  files: Array<ReposListCommitsResponseItemCommitAffectedFiles>;
+  html_url: string;
+  parents: Array<CommitMeta>;
+  sha: string;
+  stats: ReposListCommitsResponseItemCommitStats;
+  url: string;
+};
+
+export type ReposListCommitsResponse = Array<ReposListCommitsResponseItem>;
+
+export type GitGetBlobResponse = {
+  content: string;
+  encoding: string;
+  sha: string;
+  size: number;
+  url: string;
+};
+
+type GitGetTreeResponseTreeItem = {
+  mode: string;
+  path: string;
+  sha: string;
+  size?: number;
+  type: string;
+  url: string;
+};
+
+export type GitGetTreeResponse = {
+  page: number;
+  sha: string;
+  total_count: number;
+  tree: Array<GitGetTreeResponseTreeItem>;
+  truncated: boolean;
+  url: string;
+};
+
+type FileLinksResponse = {
+  git: string;
+  html: string;
+  self: string;
+};
+
+type ContentsResponse = {
+  _links: FileLinksResponse;
+  content?: string | null;
+  download_url: string;
+  encoding?: string | null;
+  git_url: string;
+  html_url: string;
+  last_commit_sha: string;
+  name: string;
+  path: string;
+  sha: string;
+  size: number;
+  submodule_git_url?: string | null;
+  target?: string | null;
+  type: string;
+  url: string;
+};
+
+type FileCommitResponse = {
+  author: CommitUser;
+  committer: CommitUser;
+  created: string;
+  html_url: string;
+  message: string;
+  parents: Array<CommitMeta>;
+  sha: string;
+  tree: CommitMeta;
+  url: string;
+};
+
+export type FilesResponse = {
+  commit: FileCommitResponse;
+  content: Array<ContentsResponse>;
+  verification: PayloadCommitVerification;
+};

package/webpack.config.js

@@ -0,0 +1,3 @@
+const { getConfig } = require('../../scripts/webpack.js');
+
+module.exports = getConfig();