decap-cms-backend-forgejo 3.4.0

package/dist/esm/implementation.js

@@ -0,0 +1,539 @@
+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, unpublishedEntries, contentKeyFromBranch, branchFromContentKey } from 'decap-cms-lib-util';
+import API, { API_NAME } from './API';
+import AuthenticationPage from './AuthenticationPage';
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+const MAX_CONCURRENT_DOWNLOADS = 10;
+const {
+  fetchWithTimeout: fetch
+} = unsentRequest;
+export default class Forgejo {
+  constructor(config, options = {}) {
+    this.options = {
+      proxied: false,
+      API: null,
+      useWorkflow: false,
+      initialWorkflowStatus: '',
+      ...options
+    };
+    if (!this.options.proxied && (config.backend.repo === null || config.backend.repo === undefined)) {
+      throw new Error('The Forgejo backend needs a "repo" in the backend configuration.');
+    }
+    if (!config.backend.api_root) {
+      throw new Error('The Forgejo backend needs an "api_root" in the backend configuration when not proxied.');
+    }
+    this.api = this.options.API || null;
+    this.openAuthoringEnabled = config.backend.open_authoring || false;
+    if (this.openAuthoringEnabled) {
+      if (!this.options.useWorkflow) {
+        throw new Error('backend.open_authoring is true but publish_mode is not set to editorial_workflow.');
+      }
+      // In open authoring mode, defer setting this.repo until after fork selection
+      this.originRepo = config.backend.repo || '';
+    } else {
+      this.repo = this.originRepo = config.backend.repo || '';
+    }
+    this.alwaysForkEnabled = config.backend.always_fork || false;
+    this.branch = config.backend.branch?.trim() || 'main';
+    this.apiRoot = config.backend.api_root;
+    this.token = '';
+    this.mediaFolder = config.media_folder;
+    this.cmsLabelPrefix = config.backend.cms_label_prefix || '';
+    this.initialWorkflowStatus = this.options.initialWorkflowStatus || 'draft';
+    this.lock = asyncLock();
+  }
+  isGitBackend() {
+    return true;
+  }
+  async status() {
+    const auth = (await this.api?.user().then(user => !!user).catch(e => {
+      console.warn('[StaticCMS] Failed getting Forgejo user', e);
+      return false;
+    })) || false;
+    return {
+      auth: {
+        status: auth
+      },
+      api: {
+        status: true,
+        statusPage: ''
+      }
+    };
+  }
+  authComponent() {
+    const wrappedAuthenticationPage = props => _jsx(AuthenticationPage, {
+      ...props,
+      backend: this
+    });
+    wrappedAuthenticationPage.displayName = 'AuthenticationPage';
+    return wrappedAuthenticationPage;
+  }
+  async currentUser({
+    token
+  }) {
+    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
+  }) {
+    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 pollUntilForkExists({
+    repo,
+    token
+  }) {
+    const initialPollDelay = 250; // milliseconds
+    const maxPollDelay = 2000; // milliseconds
+    const maxWaitMs = 60000; // overall timeout in milliseconds
+    const startTime = Date.now();
+    let pollDelay = initialPollDelay;
+    let repoExists = false;
+    while (!repoExists && Date.now() - startTime < maxWaitMs) {
+      const response = await fetch(`${this.apiRoot}${repo}`, {
+        headers: {
+          Authorization: `token ${token}`
+        }
+      });
+      if (response.ok) {
+        repoExists = true;
+      } else if (response.status === 404) {
+        repoExists = false;
+      } else {
+        // For non-404, non-OK responses, fail fast instead of looping indefinitely.
+        throw new Error(`Error while checking for fork existence: ${response.status} ${response.statusText}`);
+      }
+
+      // wait between polls if the repo does not yet exist
+      if (!repoExists) {
+        await new Promise(resolve => setTimeout(resolve, pollDelay));
+        // simple backoff up to a maximum delay
+        pollDelay = Math.min(pollDelay * 2, maxPollDelay);
+      }
+    }
+    if (!repoExists) {
+      throw new Error('Timed out waiting for fork to be created.');
+    }
+  }
+  async authenticateWithFork({
+    userData,
+    getPermissionToFork
+  }) {
+    if (!this.openAuthoringEnabled) {
+      throw new Error('Cannot authenticate with fork; Open Authoring is turned off.');
+    }
+    const token = userData.token;
+
+    // Clear cached user data when token changes to prevent stale data across logins
+    this._currentUserPromise = undefined;
+    this._userIsOriginMaintainerPromises = {};
+
+    // Origin maintainers should be able to use the CMS normally. If alwaysFork
+    // is enabled we always fork (and avoid the origin maintainer check)
+    if (!this.alwaysForkEnabled && (await this.userIsOriginMaintainer({
+      token
+    }))) {
+      this.repo = this.originRepo;
+      this.useOpenAuthoring = false;
+      return Promise.resolve();
+    }
+
+    // If a fork exists merge it with upstream
+    // otherwise create a new fork.
+    const currentUser = await this.currentUser({
+      token
+    });
+    const repoName = this.originRepo.split('/')[1];
+    this.repo = `${currentUser.login}/${repoName}`;
+    this.useOpenAuthoring = true;
+
+    // Initialize or update API for fork operations
+    // Always recreate to ensure token and repo are up to date (unless a mock was injected for testing)
+    if (!this.options.API) {
+      const apiCtor = API;
+      this.api = new apiCtor({
+        token,
+        branch: this.branch,
+        repo: this.repo,
+        originRepo: this.originRepo,
+        apiRoot: this.apiRoot,
+        useOpenAuthoring: this.useOpenAuthoring,
+        cmsLabelPrefix: this.cmsLabelPrefix,
+        initialWorkflowStatus: this.initialWorkflowStatus
+      });
+    }
+    if (await this.api.forkExists()) {
+      await this.api.mergeUpstream();
+      return Promise.resolve();
+    } else {
+      await getPermissionToFork();
+      const fork = await this.api.createFork();
+      return this.pollUntilForkExists({
+        repo: `/repos/${fork.full_name}`,
+        token
+      });
+    }
+  }
+  restoreUser(user) {
+    return this.openAuthoringEnabled ? this.authenticateWithFork({
+      userData: user,
+      // no-op: restoreUser doesn't need fork approval UX
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      getPermissionToFork: () => {}
+    }).then(() => this.authenticate(user)) : this.authenticate(user);
+  }
+  async authenticate(state) {
+    this.token = state.token;
+
+    // Clear cached user data when token changes to prevent stale data across logins
+    this._currentUserPromise = undefined;
+    this._userIsOriginMaintainerPromises = {};
+    const apiCtor = API;
+    this.api = new apiCtor({
+      token: this.token,
+      branch: this.branch,
+      repo: this.repo,
+      originRepo: this.originRepo,
+      apiRoot: this.apiRoot,
+      useOpenAuthoring: this.useOpenAuthoring,
+      cmsLabelPrefix: this.cmsLabelPrefix,
+      initialWorkflowStatus: this.initialWorkflowStatus
+    });
+    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 Forgejo 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 Forgejo user account does not have access to this repo.');
+    }
+
+    // Authorized user
+    return {
+      name: user.full_name,
+      login: user.login,
+      email: user.email,
+      avatar_url: user.avatar_url,
+      token: state.token,
+      useOpenAuthoring: this.useOpenAuthoring
+    };
+  }
+  logout() {
+    this.token = null;
+
+    // Clear cached user data on logout
+    this._currentUserPromise = undefined;
+    this._userIsOriginMaintainerPromises = {};
+    if (this.api && this.api.reset && typeof this.api.reset === 'function') {
+      return this.api.reset();
+    }
+  }
+  getToken() {
+    return Promise.resolve(this.token);
+  }
+  getCursorAndFiles = (files, page) => {
+    const pageSize = 20;
+    const count = files.length;
+    const pageCount = Math.ceil(files.length / pageSize);
+    const actions = [];
+    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, extension, depth) {
+    const repoURL = this.api.originRepoURL;
+    let 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, id) => this.api.readFile(path, id, {
+      repoURL
+    });
+    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, extension, depth) {
+    const repoURL = this.api.originRepoURL;
+    const listFiles = () => this.api.listFiles(folder, {
+      repoURL,
+      depth
+    }).then(files => files.filter(file => filterByExtension(file, extension)));
+    const readFile = (path, id) => {
+      return this.api.readFile(path, id, {
+        repoURL
+      });
+    };
+    const files = await entriesByFolder(listFiles, readFile, this.api.readFileMetadata.bind(this.api), API_NAME);
+    return files;
+  }
+  entriesByFiles(files) {
+    const repoURL = this.useOpenAuthoring ? this.api.originRepoURL : this.api.repoURL;
+    const readFile = (path, id) => this.api.readFile(path, id, {
+      repoURL
+    }).catch(() => '');
+    return entriesByFiles(files, readFile, this.api.readFileMetadata.bind(this.api), API_NAME);
+  }
+
+  // Fetches a single entry.
+  getEntry(path) {
+    const repoURL = this.api.originRepoURL;
+    return this.api.readFile(path, null, {
+      repoURL
+    }).then(data => ({
+      file: {
+        path,
+        id: null
+      },
+      data: data
+    })).catch(() => ({
+      file: {
+        path,
+        id: null
+      },
+      data: ''
+    }));
+  }
+  async getMedia(mediaFolder = this.mediaFolder, folderSupport) {
+    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) {
+    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) {
+    this._mediaDisplayURLSem = this._mediaDisplayURLSem || semaphore(MAX_CONCURRENT_DOWNLOADS);
+    return getMediaDisplayURL(displayURL, this.api.readFile.bind(this.api), this._mediaDisplayURLSem);
+  }
+  persistEntry(entry, options) {
+    // persistEntry is a transactional operation
+    return runWithLock(this.lock, () => {
+      if (options.useWorkflow) {
+        const slug = entry.dataFiles[0].slug;
+        const collection = options.collectionName;
+        const files = [...entry.dataFiles, ...entry.assets];
+        return this.api.editorialWorkflowGit(files, slug, collection, options);
+      }
+      return this.api.persistFiles(entry.dataFiles, entry.assets, options);
+    }, 'Failed to acquire persist entry lock');
+  }
+  async persistMedia(mediaFile, options) {
+    try {
+      await this.api.persistFiles([], [mediaFile], options);
+      const {
+        sha,
+        path,
+        fileObj
+      } = mediaFile;
+      const displayURL = URL.createObjectURL(fileObj);
+      return {
+        id: sha,
+        name: fileObj.name,
+        size: fileObj.size,
+        displayURL,
+        path: trimStart(path, '/')
+      };
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+  async deleteFiles(paths, commitMessage) {
+    await this.api.deleteFiles(paths, commitMessage);
+  }
+  async traverseCursor(cursor, action) {
+    const meta = cursor.meta;
+    const files = cursor.data.get('files').toJS();
+    let result;
+    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, id) => this.api.readFile(path, id, {
+      repoURL: this.api.originRepoURL
+    }).catch(() => '');
+    const entries = await entriesByFiles(result.files, readFile, this.api.readFileMetadata.bind(this.api), API_NAME);
+    return {
+      entries,
+      cursor: result.cursor
+    };
+  }
+  async unpublishedEntries() {
+    const listEntriesKeys = () => this.api.listUnpublishedBranches().then(branches => branches.map(branch => contentKeyFromBranch(branch)));
+    const ids = await unpublishedEntries(listEntriesKeys);
+    return ids;
+  }
+  async unpublishedEntry({
+    id,
+    collection,
+    slug
+  }) {
+    if (id) {
+      const data = await this.api.retrieveUnpublishedEntryData(id);
+      return data;
+    } else if (collection && slug) {
+      const contentKey = this.api.generateContentKey(collection, slug);
+      const data = await this.api.retrieveUnpublishedEntryData(contentKey);
+      return data;
+    } else {
+      throw new Error('Missing unpublished entry id or collection and slug');
+    }
+  }
+  async unpublishedEntryDataFile(collection, slug, path, id) {
+    const contentKey = this.api.generateContentKey(collection, slug);
+    const branch = branchFromContentKey(contentKey);
+    const data = await this.api.readFile(path, id, {
+      branch
+    });
+    return data;
+  }
+  async unpublishedEntryMediaFile(collection, slug, path, id) {
+    const contentKey = this.api.generateContentKey(collection, slug);
+    const branch = branchFromContentKey(contentKey);
+    const blob = await this.api.readFile(path, id, {
+      branch,
+      parseText: false
+    });
+    const name = basename(path);
+    const fileObj = blobToFileObj(name, blob);
+    return {
+      id,
+      name,
+      path,
+      size: fileObj.size,
+      displayURL: URL.createObjectURL(fileObj),
+      file: fileObj
+    };
+  }
+  updateUnpublishedEntryStatus(collection, slug, newStatus) {
+    return runWithLock(this.lock, () => this.api.updateUnpublishedEntryStatus(collection, slug, newStatus), 'Failed to acquire update entry status lock');
+  }
+  publishUnpublishedEntry(collection, slug) {
+    return runWithLock(this.lock, () => this.api.publishUnpublishedEntry(collection, slug), 'Failed to acquire publish entry lock');
+  }
+  deleteUnpublishedEntry(collection, slug) {
+    return runWithLock(this.lock, () => this.api.deleteUnpublishedEntry(collection, slug), 'Failed to acquire delete entry lock');
+  }
+  async getDeployPreview() {
+    return null;
+  }
+}

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+import ForgejoBackend from './implementation';
+import API from './API';
+import AuthenticationPage from './AuthenticationPage';
+export const DecapCmsBackendForgejo = {
+  ForgejoBackend,
+  API,
+  AuthenticationPage
+};
+export { API, AuthenticationPage, ForgejoBackend };

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "decap-cms-backend-forgejo",
+  "description": "Forgejo backend for Decap CMS",
+  "version": "3.4.0",
+  "repository": "https://github.com/decaporg/decap-cms/tree/main/packages/decap-cms-backend-forgejo",
+  "bugs": "https://github.com/decaporg/decap-cms/issues",
+  "license": "MIT",
+  "module": "dist/esm/index.js",
+  "main": "dist/decap-cms-backend-forgejo.js",
+  "keywords": [
+    "decap-cms",
+    "backend",
+    "forgejo"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "develop": "npm run build:esm -- --watch",
+    "build": "cross-env NODE_ENV=production webpack",
+    "build:esm": "cross-env NODE_ENV=esm babel src --out-dir dist/esm --ignore \"**/__tests__\" --root-mode upward --extensions \".js,.jsx,.ts,.tsx\""
+  },
+  "dependencies": {
+    "common-tags": "^1.8.0",
+    "js-base64": "^3.0.0",
+    "semaphore": "^1.1.0"
+  },
+  "peerDependencies": {
+    "@emotion/react": "^11.11.1",
+    "@emotion/styled": "^11.11.0",
+    "decap-cms-lib-auth": "^3.0.0",
+    "decap-cms-lib-util": "^3.0.0",
+    "decap-cms-ui-default": "^3.0.0",
+    "immutable": "^3.7.6",
+    "lodash": "^4.17.11",
+    "prop-types": "^15.7.2",
+    "react": "^19.1.0"
+  },
+  "gitHead": "ffe5ab7e61f4e7cb374a413bf9fe55f088d20ba2"
+}