@pranaysahith/decap-cms-backend-gitlab 3.4.0

package/dist/esm/AuthenticationPage.js

@@ -0,0 +1,126 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import { NetlifyAuthenticator, ImplicitAuthenticator, PkceAuthenticator } from 'decap-cms-lib-auth';
+import { AuthenticationPage, Icon } from 'decap-cms-ui-default';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const LoginButtonIcon = /*#__PURE__*/_styled(Icon, {
+  target: "e80yw6v0",
+  label: "LoginButtonIcon"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1gnqu05",
+  styles: "margin-right:18px"
+} : {
+  name: "1gnqu05",
+  styles: "margin-right:18px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const clientSideAuthenticators = {
+  pkce: ({
+    base_url,
+    auth_endpoint,
+    app_id,
+    auth_token_endpoint
+  }) => new PkceAuthenticator({
+    base_url,
+    auth_endpoint,
+    app_id,
+    auth_token_endpoint,
+    auth_token_endpoint_content_type: 'application/json; charset=utf-8'
+  }),
+  implicit: ({
+    base_url,
+    auth_endpoint,
+    app_id,
+    clearHash
+  }) => new ImplicitAuthenticator({
+    base_url,
+    auth_endpoint,
+    app_id,
+    clearHash
+  })
+};
+export default class GitLabAuthenticationPage extends React.Component {
+  static propTypes = {
+    onLogin: PropTypes.func.isRequired,
+    inProgress: PropTypes.bool,
+    base_url: PropTypes.string,
+    siteId: PropTypes.string,
+    authEndpoint: PropTypes.string,
+    config: PropTypes.object.isRequired,
+    clearHash: PropTypes.func,
+    t: PropTypes.func.isRequired
+  };
+  state = {};
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(GitLabAuthenticationPage.propTypes, this.props, 'prop', 'GitLabAuthenticationPage');
+    const {
+      auth_type: authType = '',
+      base_url = 'https://gitlab.com',
+      auth_endpoint = 'oauth/authorize',
+      app_id = ''
+    } = this.props.config.backend;
+    if (clientSideAuthenticators[authType]) {
+      this.auth = clientSideAuthenticators[authType]({
+        base_url,
+        auth_endpoint,
+        app_id,
+        auth_token_endpoint: 'oauth/token',
+        clearHash: this.props.clearHash
+      });
+      // Complete implicit authentication if we were redirected back to from the provider.
+      this.auth.completeAuth((err, data) => {
+        if (err) {
+          this.setState({
+            loginError: err.toString()
+          });
+          return;
+        }
+        this.props.onLogin(data);
+      });
+    } else {
+      this.auth = new NetlifyAuthenticator({
+        base_url: this.props.base_url,
+        site_id: document.location.host.split(':')[0] === 'localhost' ? 'demo.decapcms.org' : this.props.siteId,
+        auth_endpoint: this.props.authEndpoint
+      });
+    }
+  }
+  handleLogin = e => {
+    e.preventDefault();
+    this.auth.authenticate({
+      provider: 'gitlab',
+      scope: 'api'
+    }, (err, data) => {
+      if (err) {
+        this.setState({
+          loginError: err.toString()
+        });
+        return;
+      }
+      this.props.onLogin(data);
+    });
+  };
+  render() {
+    const {
+      inProgress,
+      config,
+      t
+    } = this.props;
+    return ___EmotionJSX(AuthenticationPage, {
+      onLogin: this.handleLogin,
+      loginDisabled: inProgress,
+      loginErrorMessage: this.state.loginError,
+      logoUrl: config.logo_url // Deprecated, replaced by `logo.src`
+      ,
+      logo: config.logo,
+      siteUrl: config.site_url,
+      renderButtonContent: () => ___EmotionJSX(React.Fragment, null, ___EmotionJSX(LoginButtonIcon, {
+        type: "gitlab"
+      }), ' ', inProgress ? t('auth.loggingIn') : t('auth.loginWithGitLab')),
+      t: t
+    });
+  }
+}

package/dist/esm/implementation.js

@@ -0,0 +1,358 @@
+import trimStart from 'lodash/trimStart';
+import semaphore from 'semaphore';
+import trim from 'lodash/trim';
+import { stripIndent } from 'common-tags';
+import { CURSOR_COMPATIBILITY_SYMBOL, basename, entriesByFolder, entriesByFiles, getMediaDisplayURL, getMediaAsBlob, unpublishedEntries, getPreviewStatus, asyncLock, runWithLock, getBlobSHA, blobToFileObj, contentKeyFromBranch, generateContentKey, localForage, allEntriesByFolder, filterByExtension, branchFromContentKey, getDefaultBranchName } from 'decap-cms-lib-util';
+import AuthenticationPage from './AuthenticationPage';
+import API, { API_NAME } from './API';
+const MAX_CONCURRENT_DOWNLOADS = 10;
+export default class GitLab {
+  constructor(config, options = {}) {
+    this.options = {
+      proxied: false,
+      API: null,
+      initialWorkflowStatus: '',
+      ...options
+    };
+    if (!this.options.proxied && (config.backend.repo === null || config.backend.repo === undefined)) {
+      throw new Error('The GitLab backend needs a "repo" in the backend configuration.');
+    }
+    this.api = this.options.API || null;
+    this.repo = config.backend.repo || '';
+    this.branch = config.backend.branch || 'master';
+    this.isBranchConfigured = config.backend.branch ? true : false;
+    this.apiRoot = config.backend.api_root || 'https://gitlab.com/api/v4';
+    this.token = '';
+    this.squashMerges = config.backend.squash_merges || false;
+    this.cmsLabelPrefix = config.backend.cms_label_prefix || '';
+    this.mediaFolder = config.media_folder;
+    this.previewContext = config.backend.preview_context || '';
+    this.useGraphQL = config.backend.use_graphql || false;
+    this.graphQLAPIRoot = config.backend.graphql_api_root || 'https://gitlab.com/api/graphql';
+    this.lock = asyncLock();
+  }
+  isGitBackend() {
+    return true;
+  }
+  async status() {
+    const auth = (await this.api?.user().then(user => !!user).catch(e => {
+      console.warn('Failed getting GitLab user', e);
+      return false;
+    })) || false;
+    return {
+      auth: {
+        status: auth
+      },
+      api: {
+        status: true,
+        statusPage: ''
+      }
+    };
+  }
+  authComponent() {
+    return AuthenticationPage;
+  }
+  restoreUser(user) {
+    return this.authenticate(user);
+  }
+  async authenticate(state) {
+    this.token = state.token;
+    this.api = new API({
+      token: this.token,
+      branch: this.branch,
+      repo: this.repo,
+      apiRoot: this.apiRoot,
+      squashMerges: this.squashMerges,
+      cmsLabelPrefix: this.cmsLabelPrefix,
+      initialWorkflowStatus: this.options.initialWorkflowStatus,
+      useGraphQL: this.useGraphQL,
+      graphQLAPIRoot: this.graphQLAPIRoot
+    });
+    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 GitLab account with access.
+      `;
+      throw error;
+    });
+
+    // Unauthorized user
+    if (!isCollab) {
+      throw new Error('Your GitLab user account does not have access to this repo.');
+    }
+    if (!this.isBranchConfigured) {
+      const defaultBranchName = await getDefaultBranchName({
+        backend: 'gitlab',
+        repo: this.repo,
+        token: this.token,
+        apiRoot: this.apiRoot
+      });
+      if (defaultBranchName) {
+        this.branch = defaultBranchName;
+      }
+    }
+    // Authorized user
+    return {
+      ...user,
+      login: user.username,
+      token: state.token
+    };
+  }
+  async logout() {
+    this.token = null;
+    return;
+  }
+  getToken() {
+    return Promise.resolve(this.token);
+  }
+  filterFile(folder, file, extension, depth) {
+    // gitlab paths include the root folder
+    const fileFolder = trim(file.path.split(folder)[1] || '/', '/');
+    return filterByExtension(file, extension) && fileFolder.split('/').length <= depth;
+  }
+  async entriesByFolder(folder, extension, depth) {
+    let cursor;
+    const listFiles = () => this.api.listFiles(folder, depth > 1).then(({
+      files,
+      cursor: c
+    }) => {
+      cursor = c.mergeMeta({
+        folder,
+        extension,
+        depth
+      });
+      return files.filter(file => this.filterFile(folder, file, extension, depth));
+    });
+    const files = await entriesByFolder(listFiles, this.api.readFile.bind(this.api), 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 listAllFiles(folder, extension, depth) {
+    const files = await this.api.listAllFiles(folder, depth > 1);
+    const filtered = files.filter(file => this.filterFile(folder, file, extension, depth));
+    return filtered;
+  }
+  async allEntriesByFolder(folder, extension, depth) {
+    const files = await allEntriesByFolder({
+      listAllFiles: () => this.listAllFiles(folder, extension, depth),
+      readFile: this.api.readFile.bind(this.api),
+      readFileMetadata: this.api.readFileMetadata.bind(this.api),
+      apiName: API_NAME,
+      branch: this.branch,
+      localForage,
+      folder,
+      extension,
+      depth,
+      getDefaultBranch: () => this.api.getDefaultBranch().then(b => ({
+        name: b.name,
+        sha: b.commit.id
+      })),
+      isShaExistsInBranch: this.api.isShaExistsInBranch.bind(this.api),
+      getDifferences: (to, from) => this.api.getDifferences(to, from),
+      getFileId: path => this.api.getFileId(path, this.branch),
+      filterFile: file => this.filterFile(folder, file, extension, depth),
+      customFetch: this.useGraphQL ? files => this.api.readFilesGraphQL(files) : undefined
+    });
+    return files;
+  }
+  entriesByFiles(files) {
+    return entriesByFiles(files, this.api.readFile.bind(this.api), this.api.readFileMetadata.bind(this.api), API_NAME);
+  }
+
+  // Fetches a single entry.
+  getEntry(path) {
+    return this.api.readFile(path).then(data => ({
+      file: {
+        path,
+        id: null
+      },
+      data: data
+    }));
+  }
+  getMedia(mediaFolder = this.mediaFolder) {
+    return this.api.listAllFiles(mediaFolder).then(files => files.map(({
+      id,
+      name,
+      path
+    }) => {
+      return {
+        id,
+        name,
+        path,
+        displayURL: {
+          id,
+          name,
+          path
+        }
+      };
+    }));
+  }
+  getMediaDisplayURL(displayURL) {
+    this._mediaDisplayURLSem = this._mediaDisplayURLSem || semaphore(MAX_CONCURRENT_DOWNLOADS);
+    return getMediaDisplayURL(displayURL, this.api.readFile.bind(this.api), this._mediaDisplayURLSem);
+  }
+  async getMediaFile(path) {
+    const name = basename(path);
+    const blob = await getMediaAsBlob(path, null, this.api.readFile.bind(this.api));
+    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
+    };
+  }
+  async persistEntry(entry, options) {
+    // 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, options) {
+    const fileObj = mediaFile.fileObj;
+    const [id] = await Promise.all([getBlobSHA(fileObj), this.api.persistFiles([], [mediaFile], options)]);
+    const {
+      path
+    } = mediaFile;
+    const url = URL.createObjectURL(fileObj);
+    return {
+      displayURL: url,
+      path: trimStart(path, '/'),
+      name: fileObj.name,
+      size: fileObj.size,
+      file: fileObj,
+      url,
+      id
+    };
+  }
+  deleteFiles(paths, commitMessage) {
+    return this.api.deleteFiles(paths, commitMessage);
+  }
+  traverseCursor(cursor, action) {
+    return this.api.traverseCursor(cursor, action).then(async ({
+      entries,
+      cursor: newCursor
+    }) => {
+      const [folder, depth, extension] = [cursor.meta?.get('folder'), cursor.meta?.get('depth'), cursor.meta?.get('extension')];
+      if (folder && depth && extension) {
+        entries = entries.filter(f => this.filterFile(folder, f, extension, depth));
+        newCursor = newCursor.mergeMeta({
+          folder,
+          extension,
+          depth
+        });
+      }
+      const entriesWithData = await entriesByFiles(entries, this.api.readFile.bind(this.api), this.api.readFileMetadata.bind(this.api), API_NAME);
+      return {
+        entries: entriesWithData,
+        cursor: newCursor
+      };
+    });
+  }
+  loadMediaFile(branch, file) {
+    const readFile = (path, id, {
+      parseText
+    }) => this.api.readFile(path, id, {
+      branch,
+      parseText
+    });
+    return getMediaAsBlob(file.path, null, readFile).then(blob => {
+      const name = basename(file.path);
+      const fileObj = blobToFileObj(name, blob);
+      return {
+        id: file.path,
+        displayURL: URL.createObjectURL(fileObj),
+        path: file.path,
+        name,
+        size: fileObj.size,
+        file: fileObj
+      };
+    });
+  }
+  async loadEntryMediaFiles(branch, files) {
+    const mediaFiles = await Promise.all(files.map(file => this.loadMediaFile(branch, file)));
+    return mediaFiles;
+  }
+  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 entryId = generateContentKey(collection, slug);
+      const data = await this.api.retrieveUnpublishedEntryData(entryId);
+      return data;
+    } else {
+      throw new Error('Missing unpublished entry id or collection and slug');
+    }
+  }
+  getBranch(collection, slug) {
+    const contentKey = generateContentKey(collection, slug);
+    const branch = branchFromContentKey(contentKey);
+    return branch;
+  }
+  async unpublishedEntryDataFile(collection, slug, path, id) {
+    const branch = this.getBranch(collection, slug);
+    const data = await this.api.readFile(path, id, {
+      branch
+    });
+    return data;
+  }
+  async unpublishedEntryMediaFile(collection, slug, path, id) {
+    const branch = this.getBranch(collection, slug);
+    const mediaFile = await this.loadMediaFile(branch, {
+      path,
+      id
+    });
+    return mediaFile;
+  }
+  async updateUnpublishedEntryStatus(collection, slug, newStatus) {
+    // updateUnpublishedEntryStatus is a transactional operation
+    return runWithLock(this.lock, () => this.api.updateUnpublishedEntryStatus(collection, slug, newStatus), 'Failed to acquire update entry status lock');
+  }
+  async deleteUnpublishedEntry(collection, slug) {
+    // deleteUnpublishedEntry is a transactional operation
+    return runWithLock(this.lock, () => this.api.deleteUnpublishedEntry(collection, slug), 'Failed to acquire delete entry lock');
+  }
+  async publishUnpublishedEntry(collection, slug) {
+    // publishUnpublishedEntry is a transactional operation
+    return runWithLock(this.lock, () => this.api.publishUnpublishedEntry(collection, slug), 'Failed to acquire publish entry lock');
+  }
+  async getDeployPreview(collection, slug) {
+    try {
+      const statuses = await this.api.getStatuses(collection, slug);
+      const deployStatus = getPreviewStatus(statuses, this.previewContext);
+      if (deployStatus) {
+        const {
+          target_url: url,
+          state
+        } = deployStatus;
+        return {
+          url,
+          status: state
+        };
+      } else {
+        return null;
+      }
+    } catch (e) {
+      return null;
+    }
+  }
+}

package/dist/esm/index.js

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

package/dist/esm/queries.js

@@ -0,0 +1,64 @@
+import { gql } from 'graphql-tag';
+import { oneLine } from 'common-tags';
+export const files = gql`
+  query files($repo: ID!, $branch: String!, $path: String!, $recursive: Boolean!, $cursor: String) {
+    project(fullPath: $repo) {
+      repository {
+        tree(ref: $branch, path: $path, recursive: $recursive) {
+          blobs(after: $cursor) {
+            nodes {
+              type
+              id: sha
+              path
+              name
+            }
+            pageInfo {
+              endCursor
+              hasNextPage
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+export const blobs = gql`
+  query blobs($repo: ID!, $branch: String!, $paths: [String!]!) {
+    project(fullPath: $repo) {
+      repository {
+        blobs(ref: $branch, paths: $paths) {
+          nodes {
+            id
+            data: rawBlob
+          }
+        }
+      }
+    }
+  }
+`;
+export function lastCommits(paths) {
+  const tree = paths.map((path, index) => oneLine`
+    tree${index}: tree(ref: $branch, path: "${path}") {
+      lastCommit {
+        authorName
+        authoredDate
+        author {
+          id
+          username
+          name
+          publicEmail
+        }
+      }
+    }
+  `).join('\n');
+  const query = gql`
+  query lastCommits($repo: ID!, $branch: String!) {
+    project(fullPath: $repo) {
+      repository {
+        ${tree}
+      }
+    }
+  }
+`;
+  return query;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@pranaysahith/decap-cms-backend-gitlab",
+  "description": "GitLab backend for Decap CMS",
+  "version": "3.4.0",
+  "repository": "https://github.com/decaporg/decap-cms/tree/main/packages/decap-cms-backend-gitlab",
+  "bugs": "https://github.com/decaporg/decap-cms/issues",
+  "license": "MIT",
+  "module": "dist/esm/index.js",
+  "main": "dist/decap-cms-backend-gitlab.js",
+  "keywords": [
+    "decap-cms",
+    "backend",
+    "gitlab"
+  ],
+  "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": {
+    "apollo-cache-inmemory": "^1.6.2",
+    "apollo-client": "^2.6.3",
+    "apollo-link-context": "^1.0.18",
+    "apollo-link-http": "^1.5.15",
+    "js-base64": "^3.0.0",
+    "path-browserify": "^1.0.1",
+    "semaphore": "^1.1.0"
+  },
+  "peerDependencies": {
+    "@emotion/react": "^11.11.1",
+    "@emotion/styled": "^11.11.0",
+    "@pranaysahith/decap-cms-lib-auth": "^3.0.0",
+    "@pranaysahith/decap-cms-lib-util": "^3.0.0",
+    "@pranaysahith/decap-cms-ui-default": "^3.0.0",
+    "immutable": "^3.7.6",
+    "lodash": "^4.17.11",
+    "prop-types": "^15.7.2",
+    "react": "^19.1.0"
+  },
+  "browser": {
+    "path": "path-browserify"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}