No group memberships
; 7 | } 8 | return ( 9 |
10 |
15 | );
16 | };
17 |
18 | export default DisplayGroupList;
19 |
--------------------------------------------------------------------------------
/src/client/components/GroupDataElement.jsx:
--------------------------------------------------------------------------------
1 | const GroupDataElement = ({ value, removeValue, editable }) => (
2 | List of group memberships
11 | {props.groups.map((group) => { 12 | return
18 | {rights.map((right) => (
19 |
22 | );
23 | };
24 |
25 | export default DisplayRightList;
26 |
--------------------------------------------------------------------------------
/src/util/tryMove.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const fs = require('fs-extra');
4 |
5 | module.exports = async function tryMove(from, to, suffix = 0) {
6 | if (suffix > 1000) {
7 | throw new Error('tryMove: too many retries');
8 | }
9 | let newTo = to;
10 | if (suffix > 0) {
11 | newTo += `.${suffix}`;
12 | }
13 | try {
14 | await fs.move(from, newTo);
15 | } catch (error) {
16 | if (error.code !== 'EEXIST' && error.message !== 'dest already exists.') {
17 | throw new Error(`Could not rename ${from} to ${newTo}`, {
18 | cause: error,
19 | });
20 | }
21 | await tryMove(from, to, ++suffix);
22 | }
23 | };
24 |
--------------------------------------------------------------------------------
/test/unit/config/global_config.test.js:
--------------------------------------------------------------------------------
1 | import { describe, it } from 'node:test';
2 | import { expect } from 'chai';
3 | import { getGlobalConfig } from '../../../src/config/config.js';
4 |
5 | describe('initialization of global configuration properties', () => {
6 | it('should init proxyPrefix', () => {
7 | const config = getGlobalConfig({ proxyPrefix: 'roc/' });
8 | expect(config.proxyPrefix).toBe('/roc');
9 | });
10 |
11 | it('should init publicAddress', () => {
12 | const config = getGlobalConfig({
13 | publicAddress: 'http://127.0.0.1:3300/roc/',
14 | });
15 | expect(config.publicAddress).toBe('http://127.0.0.1:3300/roc');
16 | });
17 | });
18 |
--------------------------------------------------------------------------------
/src/config/env.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const prefix = 'REST_ON_COUCH_';
4 | const debug = require('../util/debug')('roc:env-config');
5 |
6 | function getEnvConfig() {
7 | const envConfig = {};
8 | for (const name in process.env) {
9 | if (name.startsWith(prefix)) {
10 | const realName = name
11 | .substring(prefix.length)
12 | .toLowerCase()
13 | .replace(/_(?
11 |
18 | );
19 | }
20 |
21 | const mapStateToProps = (state) => {
22 | return {
23 | globalRights: state.db.globalRights,
24 | };
25 | };
26 |
27 | const GlobalRights = connect(mapStateToProps, {
28 | addGlobalRight,
29 | removeGlobalRight,
30 | })(GlobalRightsImpl);
31 |
32 | export default GlobalRights;
33 |
--------------------------------------------------------------------------------
/src/client/components/DefaultGroups.jsx:
--------------------------------------------------------------------------------
1 | import { connect } from 'react-redux';
2 |
3 | import { addDefaultGroup, removeDefaultGroup } from '../actions/db';
4 |
5 | import DefaultGroupsEditor from './DefaultGroupsEditor';
6 |
7 | function DefaultGroupsImpl(props) {
8 | if (!props.defaultGroups) return null;
9 | return (
10 | Global rights
12 |
11 |
18 | );
19 | }
20 |
21 | const mapStateToProps = (state) => {
22 | return {
23 | defaultGroups: state.db.defaultGroups,
24 | };
25 | };
26 |
27 | const DefaultGroups = connect(mapStateToProps, {
28 | addDefaultGroup,
29 | removeDefaultGroup,
30 | })(DefaultGroupsImpl);
31 |
32 | export default DefaultGroups;
33 |
--------------------------------------------------------------------------------
/test/data/byOwnerEntryUnicity.js:
--------------------------------------------------------------------------------
1 | import { resetDatabase } from '../utils/utils.js';
2 |
3 | import insertDocument from './insertDocument.js';
4 |
5 | function populate(db) {
6 | const prom = [];
7 |
8 | prom.push(
9 | insertDocument(db, {
10 | $type: 'entry',
11 | $owners: ['a@a.com', 'groupA', 'groupB'],
12 | $id: 'X',
13 | $content: {},
14 | }),
15 | insertDocument(db, {
16 | $type: 'entry',
17 | $owners: ['b@b.com', 'groupA', 'groupB'],
18 | $id: 'Y',
19 | $content: {},
20 | }),
21 | );
22 |
23 | return Promise.all(prom);
24 | }
25 |
26 | export default async function populateByOwnerUnicity() {
27 | global.couch = await resetDatabase('test-by-owner-unicity', {
28 | database: 'test-by-owner-unicity',
29 | rights: {
30 | create: ['anyuser'],
31 | },
32 | });
33 | await populate(global.couch._db);
34 | }
35 |
--------------------------------------------------------------------------------
/src/client/components/DatabaseSelector.jsx:
--------------------------------------------------------------------------------
1 | export default function DatabaseSelector({ dbName, dbList, onDbSelected }) {
2 | return (
3 | Default groups
12 |
9 |
31 |
32 | );
33 | }
34 |
--------------------------------------------------------------------------------
/src/client/components/pages/GroupMembershipsPage.jsx:
--------------------------------------------------------------------------------
1 | import { Component } from 'react';
2 | import { connect } from 'react-redux';
3 |
4 | import { dbManager } from '../../store';
5 | import DisplayGroupList from '../DisplayGroupList';
6 |
7 | class GroupMembershipsImpl extends Component {
8 | componentDidMount() {
9 | // Because if the user changed groups, then memberships need to be updated
10 | // Easier to do here than each time groups are updated
11 | dbManager.syncMemberships();
12 | }
13 |
14 | render() {
15 | return (
16 |
17 |
19 | );
20 | }
21 | }
22 |
23 | const mapStateToProps = (state) => {
24 | return {
25 | groups: state.db.memberships,
26 | };
27 | };
28 |
29 | const GroupMembershipsPage = connect(mapStateToProps)(GroupMembershipsImpl);
30 |
31 | export default GroupMembershipsPage;
32 |
--------------------------------------------------------------------------------
/test/data/insertDocument.js:
--------------------------------------------------------------------------------
1 | export default function insertDocument(db, entry) {
2 | processEntry(entry);
3 | return db.insertDocument(entry);
4 | }
5 |
6 | function processEntry(entry) {
7 | if (entry.$type === 'entry') {
8 | if (entry.$id === undefined) {
9 | entry.$id = null;
10 | }
11 | if (entry.$kind === undefined) {
12 | entry.$kind = null;
13 | }
14 | if (typeof entry.$id === 'string' && !entry._id) {
15 | entry._id = entry.$id;
16 | }
17 | }
18 | if (entry.$type === 'group') {
19 | if (typeof entry.name === 'string' && !entry._id) {
20 | entry._id = entry.name;
21 | }
22 | }
23 | if (entry.$type === 'entry' || entry.$type === 'group') {
24 | if (!entry.$creationDate) entry.$creationDate = 0;
25 | if (!entry.$modificationDate) entry.$modificationDate = 0;
26 | if (!entry.$lastModification) {
27 | entry.$lastModification = 'test@example.com';
28 | }
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/test/homeDirectories/main/test-new-import/full/import.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | module.exports = async function fullImport(ctx, result) {
4 | result.kind = 'sample';
5 | result.id = ctx.filename;
6 | result.owner = 'a@a.com';
7 | result.reference = ctx.filename;
8 | result.field = 'field';
9 | result.jpath = ['jpath', 'in', 'document'];
10 | if (ctx.fileExt === '.txt') {
11 | result.content_type = 'text/plain';
12 | }
13 | result.content = {
14 | sideEffect: true,
15 | };
16 | result.addAttachment({
17 | jpath: ['other', 'jpath'],
18 | metadata: { hasMetadata: true },
19 | reference: 'testRef',
20 | contents: Buffer.from('other attachment content', 'utf-8'),
21 | field: 'testField',
22 | filename: 'testFilename.txt',
23 | content_type: 'text/plain',
24 | });
25 | result.metadata = {
26 | hasMetadata: true,
27 | };
28 | result.addGroup('group1');
29 | result.addGroups(['group2', 'group3']);
30 | };
31 |
--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
1 | name: Release
2 |
3 | on:
4 | push:
5 | branches:
6 | - main
7 |
8 | jobs:
9 | release-please:
10 | runs-on: ubuntu-latest
11 | steps:
12 | - uses: googleapis/release-please-action@v4
13 | id: release
14 | with:
15 | token: ${{ secrets.BOT_TOKEN }}
16 | release-type: node
17 | package-name: 'rest-on-couch'
18 | - uses: actions/checkout@v5
19 | # These if statements ensure that a publication only occurs when a new release is created
20 | if: ${{ steps.release.outputs.release_created }}
21 | - uses: actions/setup-node@v5
22 | with:
23 | node-version-file: package.json
24 | registry-url: 'https://registry.npmjs.org'
25 | if: ${{ steps.release.outputs.release_created }}
26 | - run: npm publish
27 | env:
28 | NODE_AUTH_TOKEN: ${{ secrets.NPM_BOT_TOKEN }}
29 | if: ${{ steps.release.outputs.release_created }}
30 |
--------------------------------------------------------------------------------
/src/util/orcid.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | function generateCheckDigit(noHyphenOrcid) {
4 | // https://support.orcid.org/hc/en-us/articles/360006897674-Structure-of-the-ORCID-Identifier
5 | let total = 0;
6 | let zero = '0'.charCodeAt(0);
7 | for (let i = 0; i < 15; i++) {
8 | let digit = noHyphenOrcid.charCodeAt(i) - zero;
9 | total = (total + digit) * 2;
10 | }
11 | let result = (12 - (total % 11)) % 11;
12 | return result === 10 ? 'X' : String(result);
13 | }
14 |
15 | function okOrcid(orcid) {
16 | // based on https://github.com/zimeon/orcid-feed-js
17 | if (typeof orcid !== 'string') {
18 | return false;
19 | }
20 | let noHyphenOrcid = orcid.replace(
21 | /^(\d{4})-(\d{4})-(\d{4})-(\d\d\d[\dX])$/,
22 | '$1$2$3$4',
23 | );
24 | if (noHyphenOrcid === orcid) {
25 | return false;
26 | }
27 | if (noHyphenOrcid.charAt(15) !== generateCheckDigit(noHyphenOrcid)) {
28 | return false;
29 | }
30 | return true;
31 | }
32 |
33 | module.exports = okOrcid;
34 |
--------------------------------------------------------------------------------
/src/util/array_sets.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | /**
4 | *
5 | * @template T
6 | * @param A {Array
8 |
15 | );
16 | } else {
17 | let dbContent;
18 | if (!props.dbName) {
19 | dbContent = (
20 | Welcome to the dashboard!
9 |
10 | {'Please '}
11 |
29 | Currently selected database is
30 | {props.dbName}
31 |
36 |
42 | );
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/test/unit/server/routes/auth.test.js:
--------------------------------------------------------------------------------
1 | import { describe, it } from 'node:test';
2 | import { expect } from 'chai';
3 |
4 | import { getAgent } from '../../../utils/agent.js';
5 |
6 | const request = getAgent();
7 |
8 | describe('server/routes/auth', () => {
9 | describe('couchdb login', () => {
10 | it('should return 401 for wrong login credentials', () => {
11 | return request
12 | .post('/auth/login/couchdb')
13 | .send({
14 | username: 'bad',
15 | password: 'robot',
16 | })
17 | .expect(401)
18 | .then((res) => {
19 | expect(res.body).toEqual({ ok: true });
20 | });
21 | });
22 | });
23 | describe('session', () => {
24 | it('should return anonymous for unauthenticated users', () => {
25 | return request
26 | .get('/auth/session')
27 | .expect(200)
28 | .then((res) => {
29 | expect(res.body).toEqual({
30 | ok: true,
31 | authenticated: false,
32 | username: 'anonymous',
33 | provider: null,
34 | profile: null,
35 | admin: false,
36 | });
37 | });
38 | });
39 | });
40 | });
41 |
--------------------------------------------------------------------------------
/src/config/home.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const path = require('node:path');
4 | const fs = require('node:fs');
5 |
6 | const debug = require('../util/debug')('config:home');
7 |
8 | function getHomeDir() {
9 | let homeDir = process.env.REST_ON_COUCH_HOME_DIR;
10 | if (!homeDir) {
11 | debug('no home dir');
12 | return null;
13 | }
14 | return path.resolve(homeDir);
15 | }
16 |
17 | function getHomeConfig(homeDir) {
18 | const result = {};
19 | if (homeDir) {
20 | homeDir = path.resolve(homeDir);
21 | } else {
22 | homeDir = getHomeDir();
23 | }
24 | if (!homeDir) {
25 | debug('no home dir specified');
26 | return null;
27 | }
28 |
29 | debug('get home dir config from %s', homeDir);
30 | result.homeDir = homeDir;
31 | const files = fs.readdirSync(homeDir);
32 | const configFile = files.find((file) => /config\.m?js/.test(file));
33 | if (configFile) {
34 | let config = require(path.join(homeDir, configFile));
35 | debug('loaded main config file');
36 | return config;
37 | } else {
38 | debug(`no config found in home directory ${homeDir}`);
39 | return {};
40 | }
41 | }
42 |
43 | exports.getHomeDir = getHomeDir;
44 | exports.getHomeConfig = getHomeConfig;
45 |
--------------------------------------------------------------------------------
/test/homeDirectories/main/test-new-import/separate/import.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | module.exports = async function separateImport(ctx, result) {
4 | result.kind = 'sample';
5 | result.id = 'separate';
6 | result.owner = 'a@a.com';
7 | result.reference = ctx.filename;
8 | result.skipAttachment();
9 | result.skipMetadata();
10 | result.field = 'field';
11 | if (ctx.fileExt === '.txt') {
12 | result.content_type = 'text/plain';
13 | }
14 | result.content = {
15 | sideEffect: true,
16 | };
17 | result.addAttachment({
18 | jpath: ['other', 'jpath'],
19 | metadata: { hasMetadata: true },
20 | reference: 'testRef',
21 | contents: await ctx.getContents(),
22 | field: 'testField',
23 | filename: ctx.filename,
24 | content_type: 'text/plain',
25 | });
26 | result.addAttachment({
27 | jpath: ['other2', 'jpath'],
28 | reference: 'ref2',
29 | // no metadata
30 | contents: Uint8Array.of(116, 101, 115, 116, 50),
31 | field: 'testField',
32 | filename: 'test2.txt',
33 | content_type: 'text/plain',
34 | });
35 | result.metadata = {
36 | hasMetadata2: true,
37 | };
38 | result.addGroup('group1');
39 | result.addGroups(['group2', 'group3']);
40 | };
41 |
--------------------------------------------------------------------------------
/test/unit/import/import_context.test.js:
--------------------------------------------------------------------------------
1 | import fs from 'node:fs';
2 | import path from 'node:path';
3 |
4 | import { describe, it } from 'node:test';
5 | import { expect } from 'chai';
6 |
7 | import ImportContext from '../../../src/import/ImportContext.js';
8 |
9 | describe('ImportContext', () => {
10 | it('should instanciate a new import context', async () => {
11 | const file = path.join(
12 | import.meta.dirname,
13 | '../../homeDirectories/main/test-new-import/full/to_process/test.txt',
14 | );
15 | const fileContents = await fs.readFileSync(file, 'utf-8');
16 | const databaseName = 'test-new-import';
17 | const ctx = new ImportContext(file, databaseName);
18 | expect(ctx.filename).toBe('test.txt');
19 | expect(ctx.fileExt).toBe('.txt');
20 | expect(ctx.fileDir).toMatch(
21 | path.normalize('homeDirectories/main/test-new-import/full/to_process'),
22 | );
23 | expect(ctx.couch).toBeDefined();
24 | await ctx.couch.open();
25 | const fileContentsUtf8 = await ctx.getContents('utf-8');
26 | expect(fileContentsUtf8).toBe(fileContents);
27 |
28 | const dataBuffer = await ctx.getContents();
29 | expect(dataBuffer).toEqual(Buffer.from(fileContents, 'utf-8'));
30 | });
31 | });
32 |
--------------------------------------------------------------------------------
/src/client/components/GlobalRightsEditor.jsx:
--------------------------------------------------------------------------------
1 | import PropTypes from 'prop-types';
2 |
3 | import { globalRightTypes } from '../constants';
4 |
5 | import GroupDataEditor from './GroupDataEditor';
6 |
7 | const GlobalRightsEditor = ({ globalRights, addRight, removeRight }) => (
8 | {`You are logged in as ${props.user}.`}
37 | {dbContent} 38 |39 | {props.isAdmin && You are an admin of this database.} 40 |
41 |
9 |
29 | );
30 |
31 | GlobalRightsEditor.propTypes = {
32 | globalRights: PropTypes.object.isRequired,
33 | addRight: PropTypes.func.isRequired,
34 | removeRight: PropTypes.func.isRequired,
35 | };
36 |
37 | export default GlobalRightsEditor;
38 |
--------------------------------------------------------------------------------
/src/connect.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { getGlobalConfig } = require('./config/config');
4 | const CouchError = require('./util/CouchError');
5 | const debug = require('./util/debug')('main:connect');
6 | const getNano = require('./util/nanoShim');
7 |
8 | let globalNano;
9 | let lastAuthentication = 0;
10 |
11 | function open() {
12 | const authRenewal = getGlobalConfig().authRenewal * 1000;
13 | const currentDate = Date.now();
14 | if (currentDate - lastAuthentication > authRenewal) {
15 | if (lastAuthentication === 0) {
16 | debug('initialize connection to CouchDB');
17 | }
18 | globalNano = getGlobalNano();
19 | lastAuthentication = currentDate;
20 | }
21 | return globalNano;
22 | }
23 |
24 | async function getGlobalNano() {
25 | debug.trace('renew CouchDB cookie');
26 | const config = getGlobalConfig();
27 | if (config.url && config.username && config.password) {
28 | return getNano(config.url, config.username, config.password);
29 | } else {
30 | throw new CouchError(
31 | 'rest-on-couch cannot be used without url, username and password',
32 | 'fatal',
33 | );
34 | }
35 | }
36 |
37 | function close() {
38 | globalNano = null;
39 | }
40 |
41 | module.exports = {
42 | open,
43 | close,
44 | };
45 |
--------------------------------------------------------------------------------
/src/import/ImportContext.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const path = require('path');
4 |
5 | const fs = require('fs-extra');
6 |
7 | const Couch = require('..');
8 |
9 | const kFilePath = Symbol('filePath');
10 | const kContents = Symbol('contents');
11 | const kDB = Symbol('db');
12 |
13 | module.exports = class ImportContext {
14 | constructor(filePath, database) {
15 | this[kFilePath] = filePath;
16 | this[kContents] = {};
17 | this[kDB] = database;
18 | }
19 |
20 | static getSource() {
21 | return [];
22 | }
23 |
24 | get filename() {
25 | return path.parse(this[kFilePath]).base;
26 | }
27 |
28 | get fileDir() {
29 | return path.parse(this[kFilePath]).dir;
30 | }
31 |
32 | get fileExt() {
33 | return path.parse(this[kFilePath]).ext;
34 | }
35 |
36 | get couch() {
37 | return Couch.get(this[kDB]);
38 | }
39 |
40 | async getContents(encoding = null, cache = true) {
41 | if (cache) {
42 | if (!this[kContents][encoding]) {
43 | this[kContents][encoding] = await fs.readFile(
44 | this[kFilePath],
45 | encoding,
46 | );
47 | }
48 | return this[kContents][encoding];
49 | } else {
50 | return fs.readFile(this[kFilePath], encoding);
51 | }
52 | }
53 | };
54 |
--------------------------------------------------------------------------------
/src/init/auditActions.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { getGlobalConfig } = require('../config/config');
4 | const auditDesignDoc = require('../design/audit');
5 | const debug = require('../util/debug')('main:initCouch');
6 |
7 | async function setupAuditActions(nano) {
8 | debug('setup audit actions');
9 | const config = getGlobalConfig();
10 | const auditActionsDb = config.auditActionsDb;
11 | // Check if database is accessible
12 | try {
13 | const dbExists = await nano.hasDatabase(auditActionsDb);
14 | if (!dbExists) {
15 | throw new Error(
16 | `audit actions database does not exist: ${auditActionsDb}`,
17 | );
18 | }
19 | } catch (e) {
20 | debug.error('failed to get audit actions database: %s', auditActionsDb);
21 | throw e;
22 | }
23 |
24 | // Check design docs
25 | const db = nano.useDb(config.auditActionsDb);
26 | const oldDesignDoc = await db.getDocument('_design/audit');
27 | if (!oldDesignDoc || oldDesignDoc.version !== auditDesignDoc.version) {
28 | debug('updating audit design doc');
29 | const newDesignDoc = { ...auditDesignDoc };
30 | if (oldDesignDoc) {
31 | newDesignDoc._rev = oldDesignDoc._rev;
32 | }
33 | await db.insertDocument(newDesignDoc);
34 | }
35 | }
36 |
37 | module.exports = setupAuditActions;
38 |
--------------------------------------------------------------------------------
/test/unit/rights/default_groups.test.js:
--------------------------------------------------------------------------------
1 | import { beforeEach, describe, it } from 'node:test';
2 | import { expect } from 'chai';
3 |
4 | import data from '../../data/noRights.js';
5 |
6 | describe('entry reads, database with default groups', () => {
7 | beforeEach(data);
8 |
9 | it('should grant read access to owner', () => {
10 | return expect(
11 | couch.getEntry('entryWithDefaultAnonymousRead', 'x@x.com'),
12 | ).resolves.toBeDefined();
13 | });
14 |
15 | it('should grant read access to anonymous user', () => {
16 | return expect(
17 | couch.getEntry('entryWithDefaultAnonymousRead', 'anonymous'),
18 | ).resolves.toBeDefined();
19 | });
20 |
21 | it('should grant read access to logged in user', () => {
22 | return expect(
23 | couch.getEntry('entryWithDefaultAnyuserRead', 'a@a.com'),
24 | ).resolves.toBeDefined();
25 | });
26 |
27 | it('should not grant read access to anonymous user', () => {
28 | return expect(
29 | couch.getEntry('entryWithDefaultAnyuserRead', 'anonymous'),
30 | ).rejects.toThrow(/no access/);
31 | });
32 |
33 | it('should grant read access to anonymous user (multiple groups)', () => {
34 | return expect(
35 | couch.getEntry('entryWithDefaultMultiRead', 'anonymous'),
36 | ).resolves.toBeDefined();
37 | });
38 | });
39 |
--------------------------------------------------------------------------------
/src/client/components/DefaultGroupsEditor.jsx:
--------------------------------------------------------------------------------
1 | import PropTypes from 'prop-types';
2 |
3 | import GroupDataEditor from './GroupDataEditor';
4 |
5 | const DefaultGroupsEditor = ({ defaultGroups, addGroup, removeGroup }) => (
6 |
10 |
28 |
11 | {globalRightTypes.map((right, idx) => {
12 | return (
13 |
27 |
14 |
24 | );
25 | })}
26 |
15 | addRight(right, value)}
19 | removeValue={(value) => removeRight(right, value)}
20 | />
21 |
22 | {idx % 2 === 1 ? : null}
23 |
7 |
31 | );
32 |
33 | DefaultGroupsEditor.propTypes = {
34 | defaultGroups: PropTypes.object.isRequired,
35 | addGroup: PropTypes.func.isRequired,
36 | removeGroup: PropTypes.func.isRequired,
37 | };
38 |
39 | export default DefaultGroupsEditor;
40 |
--------------------------------------------------------------------------------
/test/utils/authenticate.js:
--------------------------------------------------------------------------------
1 | import { expect } from 'chai';
2 |
3 | export async function authenticateAs(agent, username, password) {
4 | await logout(agent);
5 |
6 | const loginRes = await agent
7 | .post('/auth/login/couchdb')
8 | .type('form')
9 | .send({ username, password });
10 | expect(loginRes.statusCode).toBe(200);
11 |
12 | const sessionRes = await agent.get('/auth/session');
13 | if (!sessionRes.body.authenticated) {
14 | throw new Error(
15 | `Could not authenticate on CouchDB as ${username}:${password}`,
16 | );
17 | }
18 | }
19 |
20 | export async function logout(agent) {
21 | const res = await agent.get('/auth/logout');
22 | expect(res.statusCode).toBe(200);
23 | }
24 |
25 | export function authenticateLDAP(agent, username, password) {
26 | return agent.get('/auth/logout').then((res) => {
27 | expect(res.statusCode).toBe(200);
28 | return agent
29 | .post('/auth/login/ldap')
30 | .type('form')
31 | .send({ username, password })
32 | .then((res) => {
33 | expect(res.statusCode).toBe(200);
34 | return agent.get('/auth/session');
35 | })
36 | .then((res) => {
37 | if (!res.body.authenticated) {
38 | throw new Error(
39 | `Could not authenticate on LDAP as ${username}:${password}`,
40 | );
41 | }
42 | });
43 | });
44 | }
45 |
--------------------------------------------------------------------------------
/src/constants.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | // super administrators have all these rights
4 | const { z } = require('zod');
5 | const { globalRightType } = require('./config/schema.mjs');
6 |
7 | const globalTypesSchema = z.array(globalRightType);
8 |
9 | // This list does not include the 'admin' right
10 | const globalRightTypes = globalTypesSchema.parse([
11 | 'delete',
12 | 'read',
13 | 'write',
14 | 'create',
15 | 'readGroup',
16 | 'writeGroup',
17 | 'createGroup',
18 | 'readImport',
19 | 'owner',
20 | 'addAttachment',
21 | ]);
22 |
23 | // administrators only have these rights
24 | const globalAdminRightTypes = globalTypesSchema.parse([
25 | 'admin',
26 | 'create',
27 | 'createGroup',
28 | ]);
29 |
30 | const allowedFirstLevelKeys = ['$deleted'];
31 |
32 | const IMPORT_UPDATE_FULL = 'IMPORT_UPDATE_FULL';
33 | const IMPORT_UPDATE_WITHOUT_ATTACHMENT = 'IMPORT_UPDATE_WITHOUT_ATTACHMENT';
34 | const IMPORT_UPDATE_$CONTENT_ONLY = 'IMPORT_UPDATE_$CONTENT_ONLY';
35 |
36 | module.exports = {
37 | CUSTOM_DESIGN_DOC_NAME: 'customApp',
38 | DESIGN_DOC_NAME: 'app',
39 | DESIGN_DOC_ID: '_design/app',
40 | RIGHTS_DOC_ID: 'rights',
41 | DEFAULT_GROUPS_DOC_ID: 'defaultGroups',
42 |
43 | globalRightTypes,
44 | globalAdminRightTypes,
45 | allowedFirstLevelKeys,
46 |
47 | kEntryUnicity: Symbol('entryUnicity'),
48 | IMPORT_UPDATE_FULL,
49 | IMPORT_UPDATE_WITHOUT_ATTACHMENT,
50 | IMPORT_UPDATE_$CONTENT_ONLY,
51 | };
52 |
--------------------------------------------------------------------------------
/test/unit/config/env_config.test.js:
--------------------------------------------------------------------------------
1 | import { describe, it } from 'node:test';
2 | import { expect } from 'chai';
3 | import { getGlobalConfig } from '../../../src/config/config.js';
4 |
5 | describe('REST_ON_COUCH_* environment properties', () => {
6 | it('environment booleans', () => {
7 | let config = getGlobalConfig();
8 | expect(config.proxy).toBe(true);
9 | expect(config.sessionSecure).toBe(false);
10 |
11 | process.env.REST_ON_COUCH_SESSION_SECURE = 'tru';
12 | expect(() => getGlobalConfig({})).toThrow(/Value must be a boolean/);
13 |
14 | process.env.REST_ON_COUCH_SESSION_SECURE = 'True';
15 | config = getGlobalConfig({});
16 | expect(config.sessionSecure).toBe(true);
17 |
18 | process.env.REST_ON_COUCH_PROXY = 'false';
19 | // We pass an empty config object to force reloading the configuration and not use the store
20 | config = getGlobalConfig({});
21 | expect(config.proxy).toBe(false);
22 | });
23 |
24 | it('environment integers', () => {
25 | let config = getGlobalConfig();
26 | expect(config.authRenewal).toBe(570);
27 |
28 | process.env.REST_ON_COUCH_AUTH_RENEWAL = '600x';
29 | expect(() => getGlobalConfig({})).toThrow(
30 | /Value must be a non-negative integer\n.*at authRenewal/,
31 | );
32 |
33 | process.env.REST_ON_COUCH_AUTH_RENEWAL = '600';
34 | config = getGlobalConfig({});
35 | expect(config.authRenewal).toBe(600);
36 | });
37 | });
38 |
--------------------------------------------------------------------------------
/src/client/components/LoginGoogle.jsx:
--------------------------------------------------------------------------------
1 | import PropTypes from 'prop-types';
2 | import { connect } from 'react-redux';
3 |
4 | import { checkLogin } from '../actions/login';
5 | import { API_ROOT } from '../api';
6 | import { dbManager } from '../store';
7 |
8 | import googleSigninImage from '../../../public/assets/img/logo/google_signin.png';
9 |
10 | const LoginGoogleImpl = ({ doGoogleLogin }) => (
11 |
12 |
8 |
30 |
9 |
29 |
10 |
28 |
11 | addGroup('anonymous', value)}
16 | removeValue={(value) => removeGroup('anonymous', value)}
17 | />
18 |
19 |
20 | addGroup('anyuser', value)}
24 | removeValue={(value) => removeGroup('anyuser', value)}
25 | />
26 |
27 |
18 |
26 | ));
27 | return (
28 |
29 | {props.hasCreateGroupRight ? (
30 |
34 | );
35 | };
36 |
37 | GroupsImpl.propTypes = {
38 | userGroups: PropTypes.array.isRequired,
39 | addValueToGroup: PropTypes.func.isRequired,
40 | removeValueFromGroup: PropTypes.func.isRequired,
41 | removeGroup: PropTypes.func.isRequired,
42 | };
43 |
44 | const Groups = connect(
45 | (state) => ({
46 | userGroups: state.db.userGroups,
47 | hasCreateGroupRight: state.db.userRights.includes('createGroup'),
48 | }),
49 | {
50 | addValueToGroup,
51 | removeValueFromGroup,
52 | createGroup,
53 | removeGroup,
54 | setGroupProperties,
55 | },
56 | )(GroupsImpl);
57 |
58 | export default Groups;
59 |
--------------------------------------------------------------------------------
/tools/batch/addGroupToEntryByKind.js:
--------------------------------------------------------------------------------
1 | #!/bin/env node
2 | /* eslint-disable no-console */
3 |
4 | 'use strict';
5 |
6 | /*
7 | This script allows to add group(s) to entries matching a list of kinds
8 | */
9 |
10 | const { program } = require('commander');
11 |
12 | program
13 | .option('-c --config
16 |
55 | );
56 | }
57 |
--------------------------------------------------------------------------------
/src/server/auth/ldap/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | // Doc: https://github.com/vesse/passport-ldapauth#readme
4 | const LdapStrategy = require('passport-ldapauth');
5 |
6 | const { auditLogin } = require('../../../audit/actions');
7 | const auth = require('../../middleware/auth');
8 | const util = require('../../middleware/util');
9 |
10 | exports.init = function ldapInit(passport, router, config) {
11 | const strategyConfig = {
12 | passReqToCallback: true,
13 | ...config,
14 | server: {
15 | ...config.server,
16 | },
17 | };
18 | passport.use(
19 | new LdapStrategy(strategyConfig, (req, user, done) => {
20 | const data = {
21 | provider: 'ldap',
22 | email: user.mail,
23 | info: {},
24 | };
25 | if (typeof config.getUserEmail === 'function') {
26 | data.email = config.getUserEmail(user);
27 | }
28 | if (typeof data.email !== 'string') {
29 | return done(
30 | new Error(`LDAP email must be a string. Saw ${data.email} instead.`),
31 | );
32 | }
33 | if (typeof config.getSessionProfile === 'function') {
34 | return Promise.resolve(config.getSessionProfile(user)).then(
35 | (info) => {
36 | data.profile = info;
37 | auditLogin(data.email, true, 'ldap', req.ctx);
38 | done(null, data);
39 | },
40 | (err) => done(err),
41 | );
42 | } else {
43 | auditLogin(data.email, true, 'ldap', req.ctx);
44 | done(null, data);
45 | return true;
46 | }
47 | }),
48 | );
49 |
50 | router.post(
51 | '/login/ldap',
52 | util.parseBody(),
53 | auth.afterFailure,
54 | passport.authenticate('ldapauth'),
55 | auth.afterSuccess,
56 | );
57 | };
58 |
--------------------------------------------------------------------------------
/src/client/components/GroupCreator.jsx:
--------------------------------------------------------------------------------
1 | import PropTypes from 'prop-types';
2 | import { Component } from 'react';
3 | import { connect } from 'react-redux';
4 |
5 | class GroupCreatorImpl extends Component {
6 | constructor(props) {
7 | super(props);
8 | this.state = {
9 | value: '',
10 | };
11 | }
12 |
13 | render() {
14 | const { createGroup, error } = this.props;
15 | return (
16 |
17 |
54 |
18 |
19 | rest-on-couch
20 |
21 |
22 | {rocOnline && (
23 | -
24 | {userRights.includes('createGroup') || isGroupOwner ? (
25 |
17 |
48 | );
49 | }
50 | }
51 |
52 | GroupCreatorImpl.propTypes = {
53 | createGroup: PropTypes.func.isRequired,
54 | };
55 |
56 | const mapStateToProps = (state) => {
57 | return {
58 | error: state.db.errors.createGroup,
59 | };
60 | };
61 |
62 | const GroupCreator = connect(mapStateToProps)(GroupCreatorImpl);
63 |
64 | export default GroupCreator;
65 |
--------------------------------------------------------------------------------
/.github/workflows/docker_run.yml:
--------------------------------------------------------------------------------
1 | name: Docker run
2 |
3 | on:
4 | push:
5 | branches:
6 | - main
7 | pull_request:
8 |
9 | jobs:
10 | test_docker:
11 | runs-on: ubuntu-latest
12 | services:
13 | couchdb:
14 | image: couchdb:latest
15 | env:
16 | COUCHDB_USER: admin
17 | COUCHDB_PASSWORD: admin
18 | ports:
19 | - 127.0.0.1:5984:5984
20 | ldap:
21 | image: ghcr.io/zakodium/ldap-with-users:1
22 | ports:
23 | - 127.0.0.1:1389:389
24 | steps:
25 | - uses: actions/checkout@v5
26 | - name: Setup Node.js
27 | uses: actions/setup-node@v5
28 | with:
29 | node-version-file: package.json
30 | - name: Setup test database
31 | run: node scripts/setup_database.mjs
32 | - name: Build docker image
33 | run: docker build ./ -t rest-on-couch
34 | - name: Run docker container
35 | run: |
36 | echo "Running docker container for 10s..."
37 | CONTAINER_ID=$(docker run -d \
38 | --network host \
39 | -v ./test/homeDirectories:/rest-on-couch \
40 | -e REST_ON_COUCH_HOME_DIR=/rest-on-couch/dev \
41 | -e DEBUG=couch:* \
42 | rest-on-couch)
43 |
44 | # Wait up to 10s to see if it exits
45 | if timeout 10s bash -c "docker wait $CONTAINER_ID > /dev/null"; then
46 | echo "❌ Container exited within 10 seconds."
47 | docker logs "$CONTAINER_ID"
48 | docker rm "$CONTAINER_ID" >/dev/null
49 | exit 1
50 | else
51 | docker logs "$CONTAINER_ID"
52 | echo "✅ Still running after 10 seconds (stable)."
53 | docker rm -f "$CONTAINER_ID" >/dev/null
54 | fi
55 |
--------------------------------------------------------------------------------
/test/homeDirectories/constants.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | let oidcAuthConfig;
4 | const oidcClient = process.env.OIDC_CLIENT_ID;
5 | const oidcClientSecret = process.env.OIDC_CLIENT_SECRET;
6 |
7 | if (oidcClient && oidcClientSecret) {
8 | // This dev app is configured on id.zakodium.com
9 | oidcAuthConfig = {
10 | title: 'Zakodium SSO',
11 | showLogin: true,
12 | issuer: 'https://id.zakodium.com',
13 | authorizationURL: 'https://id.zakodium.com/oauth/v2/authorize',
14 | tokenURL: 'https://id.zakodium.com/oauth/v2/token',
15 | userInfoURL: 'https://id.zakodium.com/oidc/v1/userinfo',
16 | skipUserProfile: false,
17 | storeProfileInSession: true,
18 | getEmail: function getEmail(data) {
19 | // You can customize the email extraction logic here
20 | // If data is missing from the profile, you might want to decode the jwt token directly
21 | // const jwt = require('jsonwebtoken');
22 | // const decoded = jwt.decode(data.idToken);
23 |
24 | const { profile } = data;
25 | return profile.emails?.[0]?.value;
26 | },
27 | getProfile: function getProfile(data) {
28 | return data.profile;
29 | },
30 | clientID: oidcClient,
31 | clientSecret: oidcClientSecret,
32 | };
33 | }
34 |
35 | const ldapAuthConfig = {
36 | server: {
37 | url: process.env.REST_ON_COUCH_LDAP_URL,
38 | searchBase: 'dc=zakodium,dc=com',
39 | searchFilter: 'uid={{username}}',
40 | bindDN: process.env.REST_ON_COUCH_LDAP_BIND_D_N,
41 | bindCredentials: process.env.REST_ON_COUCH_LDAP_BIND_PASSWORD,
42 | },
43 | getSessionProfile: function (user) {
44 | return {
45 | uid: user.uid,
46 | displayName: user.displayName,
47 | };
48 | },
49 | };
50 |
51 | module.exports = {
52 | ldapAuthConfig,
53 | oidcAuthConfig,
54 | };
55 |
--------------------------------------------------------------------------------
/test/unit/rest-api/couchdb_user.test.js:
--------------------------------------------------------------------------------
1 | import { before, beforeEach, describe, it } from 'node:test';
2 | import { expect } from 'chai';
3 |
4 | import { getGlobalConfig } from '../../../src/config/config.js';
5 | import getNano from '../../../src/util/nanoShim.js';
6 | import { authenticateAs } from '../../utils/authenticate.js';
7 | import { getAgent } from '../../utils/agent.js';
8 |
9 | const request = getAgent();
10 |
11 | let nano;
12 | before(async () => {
13 | const config = getGlobalConfig();
14 | nano = await getNano(config.url, 'admin', config.adminPassword);
15 | const db = nano.useDb('_users');
16 | await db.destroyDocument('org.couchdb.user:test@user.com');
17 | });
18 |
19 | describe('administrators can configure couchdb users', () => {
20 | beforeEach(async () => {
21 | await authenticateAs(request, 'admin@a.com', '123');
22 | });
23 |
24 | it('create a new user', async () => {
25 | await request
26 | .post('/auth/couchdb/user')
27 | .send({
28 | email: 'test@user.com',
29 | password: 'abc',
30 | })
31 | .expect(201)
32 | .then((res) => {
33 | expect(res.body).toEqual({ ok: true });
34 | });
35 | });
36 | });
37 |
38 | describe('non-administrators cannot configure couchdb users', () => {
39 | beforeEach(async () => {
40 | await authenticateAs(request, 'a@a.com', '123');
41 | });
42 |
43 | it('cannot create a new user', async () => {
44 | await request
45 | .post('/auth/couchdb/user')
46 | .send({
47 | email: 'test@user.com',
48 | password: 'abc',
49 | })
50 | .expect(403)
51 | .then((res) => {
52 | expect(res.body).toEqual({
53 | code: 'forbidden',
54 | error: 'restricted to administrators',
55 | });
56 | });
57 | });
58 | });
59 |
--------------------------------------------------------------------------------
/eslint.config.mjs:
--------------------------------------------------------------------------------
1 | import { defineConfig, globalIgnores } from 'eslint/config';
2 | import { globals } from 'eslint-config-zakodium';
3 | import js from 'eslint-config-zakodium/js';
4 | import react from 'eslint-config-zakodium/react';
5 |
6 | export default defineConfig(
7 | globalIgnores([
8 | 'public',
9 | 'test/homeDirectories/**',
10 | 'src/design/*',
11 | 'coverage',
12 | 'dist',
13 | ]),
14 | js,
15 | {
16 | rules: {
17 | camelcase: ['error', { properties: 'never' }],
18 | 'callback-return': 'off',
19 | 'no-await-in-loop': 'off',
20 | 'no-var': 'off',
21 | 'prefer-named-capture-group': 'off',
22 | 'import/no-dynamic-require': 'off',
23 | 'import/no-extraneous-dependencies': [
24 | 'error',
25 | // So the deep package.json files (used to specify the module format) are not taken into account.
26 | { packageDir: import.meta.dirname },
27 | ],
28 | 'import/order': 'off',
29 | },
30 | },
31 | {
32 | languageOptions: {
33 | sourceType: 'commonjs',
34 | globals: {
35 | ...globals.node,
36 | },
37 | },
38 | },
39 | {
40 | files: ['test/**'],
41 | languageOptions: {
42 | sourceType: 'module',
43 | globals: {
44 | couch: true,
45 | },
46 | },
47 | },
48 | {
49 | files: ['src/client/**/*'],
50 | languageOptions: {
51 | sourceType: 'module',
52 | globals: {
53 | ...globals.browser,
54 | },
55 | },
56 | },
57 | {
58 | files: ['src/client/**/*.jsx'],
59 | extends: [...react],
60 | },
61 | {
62 | files: ['scripts/**'],
63 | rules: {
64 | 'no-console': 'off',
65 | },
66 | },
67 | {
68 | files: ['**/*.mjs'],
69 | languageOptions: {
70 | sourceType: 'module',
71 | },
72 | },
73 | );
74 |
--------------------------------------------------------------------------------
/src/client/store.js:
--------------------------------------------------------------------------------
1 | import { applyMiddleware, createStore } from 'redux';
2 | import { persistCombineReducers, persistStore } from 'redux-persist';
3 | import storage from 'redux-persist/lib/storage';
4 | import promiseMiddleware from 'redux-promise-middleware';
5 | import { thunk as thunkMiddleware } from 'redux-thunk';
6 |
7 | import { setDbName } from './actions/db';
8 | import { getRocStatus } from './actions/main';
9 | import DbManager from './dbManager';
10 | import dbReducer from './reducers/db';
11 | import dbNameReducer from './reducers/dbName';
12 | import loginReducer from './reducers/login';
13 | import mainReducer from './reducers/main';
14 |
15 | const composeStoreWithMiddleware = applyMiddleware(
16 | promiseMiddleware,
17 | thunkMiddleware,
18 | )(createStore);
19 |
20 | const rootReducer = persistCombineReducers(
21 | {
22 | key: 'reduxPersist',
23 | storage,
24 | whitelist: ['dbName'],
25 | throttle: 1000,
26 | },
27 | {
28 | main: mainReducer,
29 | db: dbReducer,
30 | dbName: dbNameReducer,
31 | login: loginReducer,
32 | },
33 | );
34 |
35 | const store = composeStoreWithMiddleware(
36 | rootReducer,
37 | window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__(),
38 | );
39 |
40 | persistStore(store, null, onRehydrated);
41 |
42 | store.dispatch(getRocStatus());
43 |
44 | export default store;
45 | export const dbManager = new DbManager(store);
46 |
47 | function onRehydrated() {
48 | function getParameterByName(name) {
49 | const url = new URL(window.location.href);
50 | return url.searchParams.get(name);
51 | }
52 |
53 | // If url has a database name, we override the persisted database name
54 | const initialDbName = getParameterByName('database');
55 | if (initialDbName) store.dispatch(setDbName(initialDbName));
56 | dbManager.syncDb();
57 | }
58 |
--------------------------------------------------------------------------------
/src/util/token.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const randomatic = require('randomatic');
4 |
5 | const getRandomToken = () => randomatic('Aa0', 32);
6 |
7 | const CouchError = require('./CouchError');
8 | const ensureStringArray = require('./ensureStringArray');
9 |
10 | exports.createEntryToken = async function createEntryToken(
11 | db,
12 | user,
13 | uuid,
14 | rights,
15 | ) {
16 | rights = ensureStringArray(rights, 'rights');
17 | const token = {
18 | $type: 'token',
19 | $kind: 'entry',
20 | $id: getRandomToken(),
21 | $owner: user,
22 | $creationDate: Date.now(),
23 | uuid,
24 | rights,
25 | };
26 | await db.insertDocument(token);
27 | return token;
28 | };
29 |
30 | exports.createUserToken = async function createUserToken(db, user, rights) {
31 | rights = ensureStringArray(rights, 'rights');
32 | const token = {
33 | $type: 'token',
34 | $kind: 'user',
35 | $id: getRandomToken(),
36 | $owner: user,
37 | $creationDate: Date.now(),
38 | rights,
39 | };
40 | await db.insertDocument(token);
41 | return token;
42 | };
43 |
44 | exports.getToken = async function getToken(db, tokenId) {
45 | const result = await db.queryView(
46 | 'tokenById',
47 | { key: tokenId, include_docs: true },
48 | { onlyDoc: true },
49 | );
50 | if (result.length === 0) {
51 | return null;
52 | } else if (result.length === 1) {
53 | return result[0];
54 | } else {
55 | throw new CouchError('multiple tokens with the same ID', 'fatal');
56 | }
57 | };
58 |
59 | exports.getTokens = function getTokens(db, user) {
60 | return db.queryView(
61 | 'tokenByOwner',
62 | { key: user, include_docs: true },
63 | { onlyDoc: true },
64 | );
65 | };
66 |
67 | exports.destroyToken = function destroyToken(db, tokenId, rev) {
68 | return db.destroyDocument(tokenId, rev);
69 | };
70 |
--------------------------------------------------------------------------------
/src/client/reducers/login.js:
--------------------------------------------------------------------------------
1 | import {
2 | CHANGE_COUCHDB_PASSWORD,
3 | CHECK_LOGIN,
4 | CREATE_COUCHDB_USER,
5 | GET_LOGIN_PROVIDERS,
6 | LOGOUT,
7 | } from '../actions/login';
8 |
9 | const initialState = {
10 | loginProviders: [],
11 | username: null,
12 | provider: null,
13 | admin: null,
14 | errors: {},
15 | success: {},
16 | };
17 |
18 | const loginReducer = (state = initialState, action = {}) => {
19 | switch (action.type) {
20 | case `${CHECK_LOGIN}_FULFILLED`: {
21 | return { ...state, ...onLogin(action.payload) };
22 | }
23 | case `${LOGOUT}_FULFILLED`:
24 | return {
25 | ...state,
26 | errors: {},
27 | username: null,
28 | provider: null,
29 | admin: null,
30 | };
31 | case `${GET_LOGIN_PROVIDERS}_FULFILLED`:
32 | return { ...state, loginProviders: action.payload };
33 | case `${CHANGE_COUCHDB_PASSWORD}_FULFILLED`:
34 | return {
35 | ...state,
36 | errors: { changePassword: action.payload.error || '' },
37 | success: {
38 | changePassword: action.payload.error
39 | ? ''
40 | : 'Successfully changed password',
41 | },
42 | };
43 | case `${CREATE_COUCHDB_USER}_FULFILLED`:
44 | return {
45 | ...state,
46 | errors: { createUser: action.payload.error || '' },
47 | success: {
48 | createUser: action.payload.error ? '' : 'Successfully created user',
49 | },
50 | };
51 | default:
52 | return state;
53 | }
54 | };
55 |
56 | export default loginReducer;
57 |
58 | function onLogin(result) {
59 | if (!result.authenticated) {
60 | return { errors: { [result.provider]: true } };
61 | } else {
62 | return {
63 | errors: {},
64 | username: result.username,
65 | provider: result.provider,
66 | admin: result.admin,
67 | };
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/bin/rest-on-couch-log.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 |
3 | 'use strict';
4 |
5 | const { program } = require('commander');
6 |
7 | const constants = require('../src/constants');
8 | const log = require('../src/couch/log');
9 | const Couch = require('../src/index');
10 | const debug = require('../src/util/debug')('bin:log');
11 |
12 | program
13 | .option('-d, --database
18 |
20 | Create new group
19 |
21 |
41 | {error ? (
42 |
47 |
43 | {error}
44 |
45 | ) : null}
46 |
25 | {props.loginProviders.length === 0 ? 'No login provider available' : ''}
26 | {googleProvider && (
27 |
74 | );
75 | };
76 |
77 | LoginImpl.propTypes = {
78 | errors: PropTypes.object.isRequired,
79 | loginLDAP: PropTypes.func,
80 | loginProviders: PropTypes.array.isRequired,
81 | };
82 |
83 | const Login = connect(
84 | (state) => ({
85 | errors: state.login.errors,
86 | loginProviders: state.login.loginProviders.filter((p) => p.visible),
87 | }),
88 | (dispatch) => ({
89 | loginLDAP: loginLDAP(dispatch),
90 | loginCouchDB: loginCouchDB(dispatch),
91 | }),
92 | )(LoginImpl);
93 |
94 | export default Login;
95 |
--------------------------------------------------------------------------------
/src/server/auth/google/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | // provided by passport-google-oauth20
3 |
4 | // {
5 | // "user": {
6 | // "provider": "google",
7 | // "id": "100982963740157602406",
8 | // "displayName": "Daniel Kostro",
9 | // "name": {
10 | // "familyName": "Kostro",
11 | // "givenName": "Daniel"
12 | // },
13 | // "emails": [
14 | // {
15 | // "value": "kostro.d@gmail.com"
16 | // }
17 | // ],
18 | // "_raw": "{\n \"id\": \"100982963740157602406\",\n \"email\": \"kostro.d@gmail.com\",\n \"verified_email\": true,\n \"name\": \"Daniel Kostro\",\n \"given_name\": \"Daniel\",\n \"family_name\": \"Kostro\",\n \"link\": \"https://plus.google.com/+DanielKostro\",\n \"picture\": \"https://lh3.googleusercontent.com/-IvcZEni7cxM/AAAAAAAAAAI/AAAAAAAACso/4Zy9vw_ucks/photo.jpg\",\n \"gender\": \"male\"\n}\n",
19 | // "_json": {
20 | // "id": "100982963740157602406",
21 | // "email": "kostro.d@gmail.com",
22 | // "verified_email": true,
23 | // "name": "Daniel Kostro",
24 | // "given_name": "Daniel",
25 | // "family_name": "Kostro",
26 | // "link": "https://plus.google.com/+DanielKostro",
27 | // "picture": "https://lh3.googleusercontent.com/-IvcZEni7cxM/AAAAAAAAAAI/AAAAAAAACso/4Zy9vw_ucks/photo.jpg",
28 | // "gender": "male"
29 | // }
30 | // }
31 | // }
32 |
33 | const GoogleStrategy = require('passport-google-oauth20').Strategy;
34 |
35 | const { auditLogin } = require('../../../audit/actions');
36 |
37 | exports.init = function init(passport, router, authConfig, globalConfig) {
38 | // todo we should be able to put a relative callbackURL (add proxy: true) but there is a bug in passport-oauth2
39 | // with the generation of redirect_url
40 | passport.use(
41 | new GoogleStrategy(
42 | {
43 | clientID: authConfig.clientID,
44 | clientSecret: authConfig.clientSecret,
45 | callbackURL: `${globalConfig.publicAddress}/auth/login/google/callback`,
46 | passReqToCallback: true,
47 | },
48 | (req, accessToken, refreshToken, profile, done) => {
49 | const email = profile.emails[0];
50 | if (!email) {
51 | return done(null, false, { message: 'No profile email' });
52 | } else {
53 | auditLogin(email.value, true, 'google', req.ctx);
54 | done(null, {
55 | provider: 'google',
56 | email: email.value,
57 | });
58 | return true;
59 | }
60 | },
61 | ),
62 | );
63 |
64 | router.get('/login/google/popup', (ctx) => {
65 | ctx.session.popup = true;
66 | ctx.redirect('/auth/login/google');
67 | });
68 |
69 | router.get(
70 | '/login/google',
71 | passport.authenticate('google', {
72 | scope: ['https://www.googleapis.com/auth/userinfo.email'],
73 | }),
74 | );
75 |
76 | router.get(
77 | '/login/google/callback',
78 | passport.authenticate('google', {
79 | successRedirect: globalConfig.authRedirectUrl,
80 | failureRedirect: globalConfig.authRedirectUrl,
81 | }),
82 | );
83 | };
84 |
--------------------------------------------------------------------------------
/test/unit/config/load_db_config_errors.test.js:
--------------------------------------------------------------------------------
1 | import path from 'node:path';
2 | import assert from 'node:assert';
3 | import fs from 'node:fs';
4 | import { it, mock } from 'node:test';
5 | import { expect } from 'chai';
6 |
7 | import { getDbConfig, getDbConfigOrDie } from '../../../src/config/db.js';
8 |
9 | process.stderr.write = () => {
10 | // ignore
11 | };
12 | // Avoid the call to dbConfig to crash the process
13 | process.exit = () => {
14 | // ignore
15 | };
16 |
17 | it('process should die when there is a problem loading the database configuration', () => {
18 | const exit = mock.method(process, 'exit');
19 | getDbConfigOrDie(
20 | path.join(import.meta.dirname, '../../homeDirectories/failDuplicateView'),
21 | );
22 | expect(exit.mock.calls[0]?.arguments[0]).toBe(1);
23 | });
24 |
25 | it('configuration has duplicate view name', () => {
26 | expect(function load() {
27 | return getDbConfig(
28 | path.join(import.meta.dirname, '../../homeDirectories/failDuplicateView'),
29 | );
30 | }).toThrow(/a view is defined more than once: viewTest/);
31 | });
32 |
33 | it('loading configuration that has duplicate index name', () => {
34 | expect(function load() {
35 | return getDbConfig(
36 | path.join(
37 | import.meta.dirname,
38 | '../../homeDirectories/failDuplicateIndex',
39 | ),
40 | );
41 | }).toThrow(/an index is defined more than once: indexTest/);
42 | });
43 |
44 | it('loading configuration that has duplicate index name', () => {
45 | expect(function load() {
46 | return getDbConfig(
47 | path.join(
48 | import.meta.dirname,
49 | '../../homeDirectories/failShareDesignDoc',
50 | ),
51 | );
52 | }).toThrow(
53 | /query indexes and javascript views cannot share design documents: foo/,
54 | );
55 | });
56 |
57 | it('loading configuration that has duplicate names', () => {
58 | expect(function load() {
59 | return getDbConfig(
60 | path.join(import.meta.dirname, '../../homeDirectories/failShareName'),
61 | );
62 | }).toThrow(/query indexes and javascript views cannot share names: test/);
63 | });
64 |
65 | it('loading configuration with unallowed override of the filters prop', () => {
66 | expect(function load() {
67 | return getDbConfig(
68 | path.join(
69 | import.meta.dirname,
70 | '../../homeDirectories/failUnallowedOverride',
71 | ),
72 | );
73 | }).toThrow(/^customDesign\.updates cannot be overriden$/);
74 | });
75 |
76 | it('loading import.js file implemented with ESM syntax', async () => {
77 | const dir = path.join(
78 | import.meta.dirname,
79 | '../../homeDirectories/failEsmInJsFile',
80 | );
81 | assert(fs.existsSync(dir));
82 | expect(() => getDbConfig(dir)).toThrow(/Unexpected token 'export'/);
83 | });
84 |
85 | it('failEsmWrongExport - loading import.mjs with a default export instead of named export', async () => {
86 | const dir = path.join(
87 | import.meta.dirname,
88 | '../../homeDirectories/failEsmWrongExport',
89 | );
90 | assert(fs.existsSync(dir));
91 | expect(() => getDbConfig(dir)).toThrow(
92 | /import.mjs must export an `importFile` function/,
93 | );
94 | });
95 |
--------------------------------------------------------------------------------
/src/design/app.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const fs = require('fs');
4 | const path = require('path');
5 |
6 | const getConfig = require('../config/config').getConfig;
7 | const constants = require('../constants');
8 |
9 | const filters = require('./filters');
10 | const updates = require('./updates');
11 | const validateDocUpdate = require('./validateDocUpdate');
12 | const views = require('./views');
13 |
14 | /* istanbul ignore next */
15 | const mapTpl = function (doc) {
16 | if (doc.$type !== 'entry') return;
17 | var emitWithOwner = function (key, data) {
18 | for (var i = 0; i < doc.$owners.length; i++) {
19 | if (key == null) {
20 | emit([doc.$owners[i]], data);
21 | } else {
22 | emit([doc.$owners[i]].concat(key), data);
23 | }
24 | }
25 | };
26 | var customMap = CUSTOM_MAP;
27 | customMap(doc);
28 | }.toString();
29 |
30 | // Extends design doc with default views
31 | // Adds the special lib view to the design doc
32 | module.exports = function getDesignDoc(custom, dbName) {
33 | custom = custom || {};
34 | const config = getConfig(dbName);
35 | processViews(custom, config);
36 | if (custom.designDoc === constants.DESIGN_DOC_NAME) {
37 | return {
38 | _id: constants.DESIGN_DOC_ID,
39 | language: 'javascript',
40 | filters: Object.assign({}, custom.filters, filters),
41 | updates: Object.assign({}, custom.updates, updates),
42 | views: Object.assign({}, custom.views, views),
43 | validate_doc_update: validateDocUpdate,
44 | lists: Object.assign({}, custom.lists),
45 | };
46 | } else {
47 | return custom;
48 | }
49 | };
50 |
51 | function processViews(custom, config) {
52 | if (custom.views) {
53 | for (const viewName in custom.views) {
54 | const view = custom.views[viewName];
55 | if (viewName !== 'lib') {
56 | if (view.withOwner && typeof view.map === 'function') {
57 | view.map = mapTpl.replace('CUSTOM_MAP', view.map.toString());
58 | view.reduce = '_count'; // force the reduce for future optimizations.
59 | }
60 | }
61 | }
62 | }
63 | // Lib is added to all design documents
64 | if (
65 | config.customDesign &&
66 | config.customDesign.views &&
67 | config.customDesign.views.lib
68 | ) {
69 | if (!custom.views) custom.views = {};
70 | custom.views.lib = {};
71 | const view = config.customDesign.views.lib;
72 | for (const libName in view) {
73 | let lib = view[libName];
74 | if (!Array.isArray(lib)) {
75 | lib = [lib];
76 | }
77 | let libCode = lib[0];
78 | if (typeof libCode === 'string') {
79 | if (libCode.endsWith('.js')) {
80 | libCode = fs.readFileSync(
81 | path.resolve(config.homeDir, config.database, libCode),
82 | 'utf8',
83 | );
84 | }
85 | if (lib.length === 1) {
86 | custom.views.lib[libName] = libCode;
87 | } else {
88 | for (let i = 1; i < lib.length; i++) {
89 | if (custom._id === `_design/${lib[i]}`) {
90 | custom.views.lib[libName] = libCode;
91 | }
92 | }
93 | }
94 | }
95 | }
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/src/import/saveResult.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const ASCIIFolder = require('fold-to-ascii');
4 |
5 | const constants = require('../constants');
6 |
7 | module.exports = async function saveResult(importBase, result) {
8 | const couch = importBase.couch;
9 | if (result.isSkipped) return;
10 |
11 | // Create the new document if it does not exist
12 | let document = await couch.ensureExistsOrCreateEntry(
13 | result.id,
14 | result.owner,
15 | {
16 | kind: result.kind,
17 | owners: result.groups,
18 | },
19 | );
20 |
21 | // In case the document already existed, we need update the list of owners
22 | if (result.groups.length) {
23 | document = await couch.addOwnersToDoc(
24 | document.id,
25 | result.owner,
26 | result.groups,
27 | 'entry',
28 | );
29 | }
30 |
31 | const mainFilename =
32 | result.filename === null ? importBase.filename : result.filename;
33 |
34 | switch (result.getUpdateType()) {
35 | case constants.IMPORT_UPDATE_FULL:
36 | await couch.addFileToJpath(
37 | result.id,
38 | result.owner,
39 | result.jpath,
40 | result.metadata,
41 | {
42 | field: result.field,
43 | name: `${result.jpath.join('/')}/${ASCIIFolder.foldReplacing(
44 | mainFilename,
45 | '_',
46 | )}`,
47 | data: await importBase.getContents(),
48 | reference: result.reference,
49 | content_type: result.content_type,
50 | },
51 | result.content,
52 | );
53 | break;
54 | case constants.IMPORT_UPDATE_WITHOUT_ATTACHMENT:
55 | await couch.addFileToJpath(
56 | result.id,
57 | result.owner,
58 | result.jpath,
59 | result.metadata,
60 | {
61 | reference: result.reference,
62 | },
63 | result.content,
64 | true,
65 | );
66 | break;
67 | case constants.IMPORT_UPDATE_$CONTENT_ONLY:
68 | await couch.insertEntry(
69 | {
70 | $id: result.id,
71 | $kind: result.kind,
72 | $content: result.content,
73 | _id: document.id,
74 | _rev: document.rev,
75 | },
76 | result.owner,
77 | { merge: true },
78 | );
79 | break;
80 | default:
81 | throw new Error('Unreachable');
82 | }
83 |
84 | // Upload additional attachments with metadata
85 | for (const attachment of result.attachments) {
86 | const contents = Buffer.from(
87 | attachment.contents.buffer,
88 | attachment.contents.byteOffset,
89 | attachment.contents.byteLength,
90 | );
91 | await couch.addFileToJpath(
92 | result.id,
93 | result.owner,
94 | attachment.jpath,
95 | attachment.metadata,
96 | {
97 | field: attachment.field,
98 | reference: attachment.reference,
99 | name: `${attachment.jpath.join('/')}/${ASCIIFolder.foldReplacing(
100 | attachment.filename,
101 | '_',
102 | )}`,
103 | data: contents,
104 | content_type: attachment.content_type,
105 | },
106 | );
107 | }
108 |
109 | return document.id;
110 | };
111 |
--------------------------------------------------------------------------------
/src/client/components/EditableTextField.jsx:
--------------------------------------------------------------------------------
1 | import PropTypes from 'prop-types';
2 | import { Component, createRef } from 'react';
3 |
4 | class EditableTextField extends Component {
5 | constructor(props) {
6 | super(props);
7 | this.state = {
8 | editedValue: props.value || '',
9 | isEdited: false,
10 | focus: false,
11 | };
12 | this.textInput = createRef();
13 | this.handleChange = this.handleChange.bind(this);
14 | this.handleSubmit = this.handleSubmit.bind(this);
15 | this.handleKeyPress = this.handleKeyPress.bind(this);
16 | this.handleKeyDown = this.handleKeyDown.bind(this);
17 | this.cancelEdit = this.cancelEdit.bind(this);
18 | this.makeEditable = this.makeEditable.bind(this);
19 | }
20 |
21 | componentDidUpdate() {
22 | if (this.state.focus) {
23 | this.textInput.current.focus();
24 | this.textInput.current.select();
25 | }
26 | }
27 |
28 | handleChange(event) {
29 | this.setState({
30 | editedValue: event.target.value,
31 | focus: false,
32 | });
33 | }
34 |
35 | handleSubmit() {
36 | if (this.isEmpty()) return;
37 | this.props.onSubmit(this.state.editedValue);
38 | this.setState({
39 | isEdited: false,
40 | focus: false,
41 | });
42 | }
43 |
44 | handleKeyDown(event) {
45 | // For some reason escape key is not handled by key press
46 | if (event.key === 'Escape') {
47 | this.cancelEdit();
48 | }
49 | }
50 |
51 | handleKeyPress(event) {
52 | if (event.key === 'Enter') {
53 | event.preventDefault();
54 | this.handleSubmit();
55 | }
56 | }
57 |
58 | cancelEdit() {
59 | this.setState({
60 | isEdited: false,
61 | editedValue: this.props.value,
62 | focus: false,
63 | });
64 | }
65 |
66 | makeEditable() {
67 | this.setState({
68 | isEdited: true,
69 | focus: true,
70 | });
71 | }
72 |
73 | isEmpty() {
74 | return this.state.editedValue === '';
75 | }
76 |
77 | render() {
78 | const { label, value } = this.props;
79 | return (
80 |
109 | );
110 | }
111 | }
112 |
113 | EditableTextField.propTypes = {
114 | onSubmit: PropTypes.func.isRequired,
115 | value: PropTypes.string,
116 | };
117 |
118 | export default EditableTextField;
119 |
--------------------------------------------------------------------------------
/src/client/components/CreateUser.jsx:
--------------------------------------------------------------------------------
1 | import { Component } from 'react';
2 | import { connect } from 'react-redux';
3 |
4 | import { createCouchDBUser } from '../actions/login';
5 |
6 | class CreateUserImpl extends Component {
7 | constructor(props) {
8 | super(props);
9 | this.state = {
10 | email: '',
11 | password: '',
12 | };
13 | this.handleChange = this.handleChange.bind(this);
14 | this.handleSubmit = this.handleSubmit.bind(this);
15 | this.handleKeyPress = this.handleKeyPress.bind(this);
16 | }
17 |
18 | handleChange(event) {
19 | this.setState({
20 | [event.target.name]: event.target.value,
21 | });
22 | }
23 |
24 | handleSubmit() {
25 | if (this.isEmpty()) return;
26 | this.props.createCouchDBUser(this.state.email, this.state.password);
27 | }
28 |
29 | handleKeyPress(event) {
30 | if (event.key === 'Enter') this.handleSubmit();
31 | }
32 |
33 | isEmpty() {
34 | return this.state.email === '' || this.state.password === '';
35 | }
36 |
37 | render() {
38 | return (
39 |
28 |
35 | )}
36 | {ldapProvider && (
37 |
29 |
31 | {googleProvider.title}
30 |
32 |
34 |
38 |
45 | )}
46 | {couchdbProvider && (
47 |
39 |
41 | {ldapProvider.title}
40 |
42 |
44 |
48 |
58 | )}
59 | {oidcProvider && (
60 |
49 |
51 | {couchdbProvider.title}
50 |
52 |
57 |
61 |
72 | )}
73 |
62 |
64 |
71 | {oidcProvider.title}
63 |
40 |
91 | );
92 | }
93 | }
94 |
95 | function mapStateToProps(state) {
96 | return {
97 | username: state.login.username,
98 | error: state.login.errors.createUser,
99 | success: state.login.success.createUser,
100 | };
101 | }
102 |
103 | const CreateUser = connect(mapStateToProps, { createCouchDBUser })(
104 | CreateUserImpl,
105 | );
106 |
107 | export default CreateUser;
108 |
--------------------------------------------------------------------------------
/src/couch/doc.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const CouchError = require('../util/CouchError');
4 | const debug = require('../util/debug')('main:doc');
5 |
6 | const nanoMethods = require('./nano');
7 | const util = require('./util');
8 | const validate = require('./validate');
9 | const { union, difference } = require('../util/array_sets.js');
10 |
11 | const methods = {
12 | async getDocUuidFromId(id, user, type) {
13 | await this.open();
14 | return nanoMethods.getUuidFromId(this._db, id, user, type);
15 | },
16 |
17 | async getDocByRights(uuid, user, rights, type, options) {
18 | debug.trace('getDocByRights');
19 | await this.open();
20 | if (!util.isManagedDocumentType(type)) {
21 | throw new CouchError(`invalid type argument: ${type}`);
22 | }
23 |
24 | const doc = await this._db.getDocument(uuid);
25 | if (!doc) {
26 | throw new CouchError('document not found', 'not found');
27 | }
28 | if (doc.$type !== type) {
29 | throw new CouchError(
30 | `wrong document type: ${doc.$type}. Expected: ${type}`,
31 | );
32 | }
33 |
34 | const token = options ? options.token : null;
35 | if (
36 | await validate.validateTokenOrRights(
37 | this,
38 | uuid,
39 | doc.$owners,
40 | rights,
41 | user,
42 | token,
43 | type,
44 | )
45 | ) {
46 | return this._db.getDocument(uuid, options);
47 | }
48 | throw new CouchError('user has no access', 'unauthorized');
49 | },
50 |
51 | async addOwnersToDoc(uuid, user, owners, type, options) {
52 | debug('addOwnersToDoc (%s, %s)', uuid, user);
53 | await this.open();
54 | owners = util.ensureOwnersArray(owners);
55 | const doc = await this.getDocByRights(uuid, user, 'owner', type, options);
56 | doc.$owners = union(doc.$owners, owners);
57 | return nanoMethods.save(this._db, doc, user);
58 | },
59 |
60 | async removeOwnersFromDoc(uuid, user, owners, type, options) {
61 | debug.trace('removeOwnersFromDoc (%s, %s)', uuid, user);
62 | await this.open();
63 | owners = util.ensureOwnersArray(owners);
64 | const doc = await this.getDocByRights(uuid, user, 'owner', type, options);
65 | const mainOwner = doc.$owners[0];
66 | if (owners.includes(mainOwner)) {
67 | throw new CouchError('cannot remove primary owner', 'forbidden');
68 | }
69 | const newArray = difference(doc.$owners.slice(1), owners);
70 | newArray.unshift(doc.$owners[0]);
71 | doc.$owners = newArray;
72 | return nanoMethods.save(this._db, doc, user);
73 | },
74 |
75 | async getDocsAsOwner(user, type, options) {
76 | debug.trace('getDocsAsOwner');
77 | await this.open();
78 | options = { ...options };
79 | if (this.isSuperAdmin(user)) {
80 | return this._db.queryView(
81 | 'documentByType',
82 | {
83 | key: type,
84 | include_docs: true,
85 | },
86 | options,
87 | );
88 | } else {
89 | return this._db.queryView(
90 | 'documentByOwners',
91 | {
92 | key: [type, user],
93 | include_docs: true,
94 | },
95 | options,
96 | );
97 | }
98 | },
99 | };
100 |
101 | module.exports = {
102 | methods,
103 | };
104 |
--------------------------------------------------------------------------------
/src/client/components/ChangePassword.jsx:
--------------------------------------------------------------------------------
1 | import { Component } from 'react';
2 | import { connect } from 'react-redux';
3 |
4 | import { changeCouchDBPassword } from '../actions/login';
5 |
6 | class ChangePasswordImpl extends Component {
7 | constructor(props) {
8 | super(props);
9 | this.state = {
10 | oldPassword: '',
11 | newPassword: '',
12 | };
13 | this.handleChange = this.handleChange.bind(this);
14 | this.handleSubmit = this.handleSubmit.bind(this);
15 | this.handleKeyPress = this.handleKeyPress.bind(this);
16 | }
17 |
18 | handleChange(event) {
19 | this.setState({
20 | [event.target.name]: event.target.value,
21 | });
22 | }
23 |
24 | handleSubmit() {
25 | if (this.isEmpty()) return;
26 | this.props.changeCouchDBPassword(
27 | this.state.oldPassword,
28 | this.state.newPassword,
29 | );
30 | this.setState({
31 | oldPassword: '',
32 | newPassword: '',
33 | });
34 | }
35 |
36 | handleKeyPress(event) {
37 | if (event.key === 'Enter') this.handleSubmit();
38 | }
39 |
40 | isEmpty() {
41 | return this.state.oldPassword === '' || this.state.newPassword === '';
42 | }
43 |
44 | render() {
45 | return (
46 | Create a new user
41 | 90 |
47 |
100 | );
101 | }
102 | }
103 |
104 | function mapStateToProps(state) {
105 | return {
106 | username: state.login.username,
107 | error: state.login.errors.changePassword,
108 | success: state.login.success.changePassword,
109 | };
110 | }
111 |
112 | const ChangePassword = connect(mapStateToProps, { changeCouchDBPassword })(
113 | ChangePasswordImpl,
114 | );
115 |
116 | export default ChangePassword;
117 |
--------------------------------------------------------------------------------
/test/data/noRights.js:
--------------------------------------------------------------------------------
1 | import { resetDatabase } from '../utils/utils.js';
2 |
3 | import insertDocument from './insertDocument.js';
4 |
5 | function populate(db) {
6 | const prom = [];
7 | // Default groups
8 | prom.push(
9 | (async () => {
10 | const doc = await db.getDocument('defaultGroups');
11 | await db.insertDocument({
12 | _id: 'defaultGroups',
13 | _rev: doc._rev,
14 | $type: 'db',
15 | anonymous: ['defaultAnonymousRead', 'inexistantGroup'],
16 | anyuser: ['defaultAnyuserRead'],
17 | });
18 | })(),
19 | );
20 |
21 | // Groups
22 | prom.push(
23 | insertDocument(db, {
24 | $type: 'group',
25 | $owners: ['a@a.com'],
26 | name: 'groupA',
27 | users: ['a@a.com'],
28 | customUsers: ['a@a.com'],
29 | rights: ['create', 'write', 'delete', 'read'],
30 | }),
31 | );
32 |
33 | prom.push(
34 | insertDocument(db, {
35 | $type: 'group',
36 | $owners: ['a@a.com'],
37 | name: 'groupB',
38 | users: ['b@b.com', 'c@c.com'],
39 | customUsers: ['b@b.com', 'c@c.com'],
40 | rights: ['create'],
41 | }),
42 | );
43 |
44 | prom.push(
45 | insertDocument(db, {
46 | $type: 'group',
47 | $owners: ['a@a.com'],
48 | name: 'defaultAnonymousRead',
49 | users: [],
50 | customUsers: [],
51 | rights: ['read'],
52 | }),
53 | );
54 |
55 | prom.push(
56 | insertDocument(db, {
57 | $type: 'group',
58 | $owners: ['a@a.com'],
59 | name: 'defaultAnyuserRead',
60 | users: [],
61 | customUsers: [],
62 | rights: ['read'],
63 | }),
64 | );
65 |
66 | // Entries
67 | prom.push(
68 | insertDocument(db, {
69 | $type: 'entry',
70 | $owners: ['b@b.com', 'groupA', 'groupB'],
71 | $id: 'A',
72 | $content: {
73 | x: 1,
74 | },
75 | }),
76 | );
77 |
78 | prom.push(
79 | insertDocument(db, {
80 | $type: 'entry',
81 | $owners: ['b@b.com'],
82 | $id: 'onlyB',
83 | $content: {
84 | x: 2,
85 | },
86 | }),
87 | );
88 |
89 | prom.push(
90 | insertDocument(db, {
91 | $type: 'entry',
92 | $owners: ['a@a.com'],
93 | $id: 'onlyA',
94 | $content: {
95 | x: 3,
96 | },
97 | }),
98 | );
99 |
100 | prom.push(
101 | insertDocument(db, {
102 | $type: 'entry',
103 | $owners: ['x@x.com', 'defaultAnonymousRead'],
104 | $id: 'entryWithDefaultAnonymousRead',
105 | $content: {
106 | x: 4,
107 | },
108 | }),
109 | );
110 |
111 | prom.push(
112 | insertDocument(db, {
113 | $type: 'entry',
114 | $owners: ['x@x.com', 'defaultAnyuserRead'],
115 | $id: 'entryWithDefaultAnyuserRead',
116 | $content: {
117 | x: 5,
118 | },
119 | }),
120 | );
121 |
122 | prom.push(
123 | insertDocument(db, {
124 | $type: 'entry',
125 | $owners: ['x@x.com', 'defaultAnonymousRead', 'defaultAnyuserRead'],
126 | $id: 'entryWithDefaultMultiRead',
127 | $content: {
128 | x: 6,
129 | },
130 | }),
131 | );
132 |
133 | // Tokens
134 | prom.push(
135 | insertDocument(db, {
136 | $type: 'token',
137 | $kind: 'entry',
138 | $owner: 'x@x.com',
139 | $id: 'mytoken',
140 | $creationDate: 0,
141 | uuid: 'A',
142 | rights: ['read'],
143 | }),
144 | );
145 |
146 | return Promise.all(prom);
147 | }
148 |
149 | export default async function createDatabase() {
150 | global.couch = await resetDatabase('test');
151 | await populate(global.couch._db);
152 | }
153 |
--------------------------------------------------------------------------------
/views/login.hbs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Change password
48 | 99 |
40 | {{sessionMessage}}
41 |
42 | {{/if}}
43 | {{#if google }}
44 |
45 |
50 | {{/if }}
51 |
52 | {{#if ldap }}
53 | Google login
46 |
47 | 
48 |
54 |
65 | {{/if }}
66 |
67 | {{#if couchdb }}
68 | {{ pluginConfig.ldap.title }}
55 |56 |
63 | 64 |
69 |
80 | {{/if }}
81 |
82 | {{#if oidc }}
83 | {{ pluginConfig.couchdb.title }}
70 |71 |
78 | 79 |
84 |
89 | {{/if }}
90 |
91 |
118 |
119 |
120 |
--------------------------------------------------------------------------------
{{ pluginConfig.oidc.title }}
85 |86 | Click here to login with {{ pluginConfig.oidc.title }} 87 |
88 |