@nocobase/plugin-auth 0.10.0-alpha.2

package/lib/client/settings/schemas/authenticators.js

@@ -0,0 +1,438 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFormSchema = exports.authenticatorsSchema = void 0;
+function _shared() {
+  const data = require("@formily/shared");
+  _shared = function _shared() {
+    return data;
+  };
+  return data;
+}
+function _client() {
+  const data = require("@nocobase/client");
+  _client = function _client() {
+    return data;
+  };
+  return data;
+}
+function _react() {
+  const data = require("react");
+  _react = function _react() {
+    return data;
+  };
+  return data;
+}
+var _authType = require("../authType");
+function _antd() {
+  const data = require("antd");
+  _antd = function _antd() {
+    return data;
+  };
+  return data;
+}
+function _reactI18next() {
+  const data = require("react-i18next");
+  _reactI18next = function _reactI18next() {
+    return data;
+  };
+  return data;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const collection = {
+  name: 'authenticators',
+  sortable: true,
+  fields: [{
+    name: 'id',
+    type: 'string',
+    interface: 'id'
+  }, {
+    interface: 'input',
+    type: 'string',
+    name: 'name',
+    uiSchema: {
+      type: 'string',
+      title: '{{t("Name")}}',
+      'x-component': 'Input',
+      required: true
+    }
+  }, {
+    interface: 'input',
+    type: 'string',
+    name: 'authType',
+    uiSchema: {
+      type: 'string',
+      title: '{{t("Auth Type", {ns: "auth"})}}',
+      'x-component': 'Select',
+      required: true
+    }
+  }, {
+    interface: 'input',
+    type: 'string',
+    name: 'title',
+    uiSchema: {
+      type: 'string',
+      title: '{{t("Title")}}',
+      'x-component': 'Input'
+    }
+  }, {
+    interface: 'textarea',
+    type: 'string',
+    name: 'description',
+    uiSchema: {
+      type: 'string',
+      title: '{{t("Description")}}',
+      'x-component': 'Input'
+    }
+  }, {
+    type: 'boolean',
+    name: 'enabled',
+    uiSchema: {
+      type: 'boolean',
+      title: '{{t("Enabled")}}',
+      'x-component': 'Checkbox'
+    }
+  }]
+};
+const createFormSchema = {
+  type: 'object',
+  properties: {
+    drawer: {
+      type: 'void',
+      'x-component': 'Action.Drawer',
+      'x-decorator': 'Form',
+      'x-decorator-props': {
+        useValues(options) {
+          const ctx = (0, _client().useActionContext)();
+          const _useContext = (0, _react().useContext)(_authType.AuthTypeContext),
+            authType = _useContext.type;
+          return (0, _client().useRequest)(() => Promise.resolve({
+            data: {
+              name: `s_${(0, _shared().uid)()}`,
+              authType
+            }
+          }), _objectSpread(_objectSpread({}, options), {}, {
+            refreshDeps: [ctx.visible]
+          }));
+        }
+      },
+      title: '{{t("Add new")}}',
+      properties: {
+        name: {
+          'x-component': 'CollectionField',
+          'x-decorator': 'FormItem'
+        },
+        authType: {
+          'x-component': 'CollectionField',
+          'x-decorator': 'FormItem',
+          'x-component-props': {
+            options: '{{ types }}'
+          }
+        },
+        title: {
+          'x-component': 'CollectionField',
+          'x-decorator': 'FormItem'
+        },
+        description: {
+          'x-component': 'CollectionField',
+          'x-decorator': 'FormItem'
+        },
+        enabled: {
+          'x-component': 'CollectionField',
+          'x-decorator': 'FormItem'
+        },
+        options: {
+          type: 'object',
+          'x-component': 'Options'
+        },
+        footer: {
+          type: 'void',
+          'x-component': 'Action.Drawer.Footer',
+          properties: {
+            cancel: {
+              title: '{{t("Cancel")}}',
+              'x-component': 'Action',
+              'x-component-props': {
+                useAction: '{{ cm.useCancelAction }}'
+              }
+            },
+            submit: {
+              title: '{{t("Submit")}}',
+              'x-component': 'Action',
+              'x-component-props': {
+                type: 'primary',
+                useAction: '{{ cm.useCreateAction }}'
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+exports.createFormSchema = createFormSchema;
+const authenticatorsSchema = {
+  type: 'void',
+  name: 'authenticators',
+  'x-decorator': 'ResourceActionProvider',
+  'x-decorator-props': {
+    collection,
+    resourceName: 'authenticators',
+    dragSort: true,
+    request: {
+      resource: 'authenticators',
+      action: 'list',
+      params: {
+        pageSize: 50,
+        sort: 'sort',
+        appends: []
+      }
+    }
+  },
+  'x-component': 'CollectionProvider',
+  'x-component-props': {
+    collection
+  },
+  properties: {
+    actions: {
+      type: 'void',
+      'x-component': 'ActionBar',
+      'x-component-props': {
+        style: {
+          marginBottom: 16
+        }
+      },
+      properties: {
+        delete: {
+          type: 'void',
+          title: '{{t("Delete")}}',
+          'x-component': 'Action',
+          'x-component-props': {
+            useAction: '{{ cm.useBulkDestroyAction }}',
+            confirm: {
+              title: "{{t('Delete')}}",
+              content: "{{t('Are you sure you want to delete it?')}}"
+            }
+          }
+        },
+        create: {
+          type: 'void',
+          title: '{{t("Add new")}}',
+          'x-component': 'AddNew',
+          'x-component-props': {
+            type: 'primary'
+          }
+        }
+      }
+    },
+    table: {
+      type: 'void',
+      'x-uid': 'input',
+      'x-component': 'Table.Void',
+      'x-component-props': {
+        rowKey: 'id',
+        rowSelection: {
+          type: 'checkbox'
+        },
+        useDataSource: '{{ cm.useDataSourceFromRAC }}',
+        useAction() {
+          const api = (0, _client().useAPIClient)();
+          const _useTranslation = (0, _reactI18next().useTranslation)(),
+            t = _useTranslation.t;
+          return {
+            move(from, to) {
+              return _asyncToGenerator(function* () {
+                yield api.resource('authenticators').move({
+                  sourceId: from.id,
+                  targetId: to.id
+                });
+                _antd().message.success(t('Saved successfully'), 0.2);
+              })();
+            }
+          };
+        }
+      },
+      properties: {
+        id: {
+          type: 'void',
+          'x-decorator': 'Table.Column.Decorator',
+          'x-component': 'Table.Column',
+          properties: {
+            id: {
+              type: 'number',
+              'x-component': 'CollectionField',
+              'x-read-pretty': true
+            }
+          }
+        },
+        name: {
+          type: 'void',
+          'x-decorator': 'Table.Column.Decorator',
+          'x-component': 'Table.Column',
+          properties: {
+            name: {
+              type: 'string',
+              'x-component': 'CollectionField',
+              'x-read-pretty': true
+            }
+          }
+        },
+        authType: {
+          type: 'void',
+          'x-decorator': 'Table.Column.Decorator',
+          'x-component': 'Table.Column',
+          properties: {
+            authType: {
+              type: 'string',
+              'x-component': 'CollectionField',
+              'x-read-pretty': true
+            }
+          }
+        },
+        title: {
+          type: 'void',
+          'x-decorator': 'Table.Column.Decorator',
+          'x-component': 'Table.Column',
+          properties: {
+            title: {
+              type: 'string',
+              'x-component': 'CollectionField',
+              'x-read-pretty': true
+            }
+          }
+        },
+        description: {
+          type: 'void',
+          'x-decorator': 'Table.Column.Decorator',
+          'x-component': 'Table.Column',
+          properties: {
+            description: {
+              type: 'boolean',
+              'x-component': 'CollectionField',
+              'x-read-pretty': true
+            }
+          }
+        },
+        enabled: {
+          type: 'void',
+          'x-decorator': 'Table.Column.Decorator',
+          'x-component': 'Table.Column',
+          properties: {
+            enabled: {
+              type: 'boolean',
+              'x-component': 'CollectionField',
+              'x-read-pretty': true
+            }
+          }
+        },
+        actions: {
+          type: 'void',
+          title: '{{t("Actions")}}',
+          'x-component': 'Table.Column',
+          properties: {
+            actions: {
+              type: 'void',
+              'x-component': 'Space',
+              'x-component-props': {
+                split: '|'
+              },
+              properties: {
+                update: {
+                  type: 'void',
+                  title: '{{t("Configure")}}',
+                  'x-component': 'Action.Link',
+                  'x-component-props': {
+                    type: 'primary'
+                  },
+                  properties: {
+                    drawer: {
+                      type: 'void',
+                      'x-component': 'Action.Drawer',
+                      'x-decorator': 'Form',
+                      'x-decorator-props': {
+                        useValues: '{{ cm.useValuesFromRecord }}'
+                      },
+                      title: '{{t("Configure")}}',
+                      properties: {
+                        name: {
+                          'x-component': 'CollectionField',
+                          'x-decorator': 'FormItem'
+                        },
+                        authType: {
+                          'x-component': 'CollectionField',
+                          'x-decorator': 'FormItem',
+                          'x-component-props': {
+                            options: '{{ types }}'
+                          }
+                        },
+                        title: {
+                          'x-component': 'CollectionField',
+                          'x-decorator': 'FormItem'
+                        },
+                        description: {
+                          'x-component': 'CollectionField',
+                          'x-decorator': 'FormItem'
+                        },
+                        enabled: {
+                          'x-component': 'CollectionField',
+                          'x-decorator': 'FormItem'
+                        },
+                        options: {
+                          type: 'object',
+                          'x-component': 'Options'
+                        },
+                        footer: {
+                          type: 'void',
+                          'x-component': 'Action.Drawer.Footer',
+                          properties: {
+                            cancel: {
+                              title: '{{t("Cancel")}}',
+                              'x-component': 'Action',
+                              'x-component-props': {
+                                useAction: '{{ cm.useCancelAction }}'
+                              }
+                            },
+                            submit: {
+                              title: '{{t("Submit")}}',
+                              'x-component': 'Action',
+                              'x-component-props': {
+                                type: 'primary',
+                                useAction: '{{ cm.useUpdateAction }}'
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                },
+                delete: {
+                  type: 'void',
+                  title: '{{ t("Delete") }}',
+                  'x-component': 'Action.Link',
+                  'x-component-props': {
+                    confirm: {
+                      title: "{{t('Delete record')}}",
+                      content: "{{t('Are you sure you want to delete it?')}}"
+                    },
+                    useAction: '{{cm.useDestroyAction}}'
+                  },
+                  'x-disabled': '{{ useCanNotDelete() }}'
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+exports.authenticatorsSchema = authenticatorsSchema;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { default, AuthModel } from './server';

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AuthModel", {
+  enumerable: true,
+  get: function get() {
+    return _server.AuthModel;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _server.default;
+  }
+});
+var _server = _interopRequireWildcard(require("./server"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/lib/preset.d.ts

@@ -0,0 +1,3 @@
+export declare const presetAuthType = "Email/Password";
+export declare const presetAuthenticator = "basic";
+export declare const namespace: any;

package/lib/preset.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.presetAuthenticator = exports.presetAuthType = exports.namespace = void 0;
+const presetAuthType = 'Email/Password';
+exports.presetAuthType = presetAuthType;
+const presetAuthenticator = 'basic';
+exports.presetAuthenticator = presetAuthenticator;
+const namespace = require('../package.json').name;
+exports.namespace = namespace;

package/lib/server/actions/auth.d.ts

@@ -0,0 +1,8 @@
+import { Context, Next } from '@nocobase/actions';
+declare const _default: {
+    lostPassword: (ctx: Context, next: Next) => Promise<void>;
+    resetPassword: (ctx: Context, next: Next) => Promise<void>;
+    getUserByResetToken: (ctx: Context, next: Next) => Promise<void>;
+    changePassword: (ctx: Context, next: Next) => Promise<void>;
+};
+export default _default;

package/lib/server/actions/auth.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+var _default = {
+  lostPassword: function () {
+    var _lostPassword = _asyncToGenerator(function* (ctx, next) {
+      ctx.body = yield ctx.auth.lostPassword();
+      yield next();
+    });
+    function lostPassword(_x, _x2) {
+      return _lostPassword.apply(this, arguments);
+    }
+    return lostPassword;
+  }(),
+  resetPassword: function () {
+    var _resetPassword = _asyncToGenerator(function* (ctx, next) {
+      ctx.body = yield ctx.auth.resetPassword();
+      yield next();
+    });
+    function resetPassword(_x3, _x4) {
+      return _resetPassword.apply(this, arguments);
+    }
+    return resetPassword;
+  }(),
+  getUserByResetToken: function () {
+    var _getUserByResetToken = _asyncToGenerator(function* (ctx, next) {
+      ctx.body = yield ctx.auth.getUserByResetToken();
+      yield next();
+    });
+    function getUserByResetToken(_x5, _x6) {
+      return _getUserByResetToken.apply(this, arguments);
+    }
+    return getUserByResetToken;
+  }(),
+  changePassword: function () {
+    var _changePassword = _asyncToGenerator(function* (ctx, next) {
+      ctx.body = yield ctx.auth.changePassword();
+      yield next();
+    });
+    function changePassword(_x7, _x8) {
+      return _changePassword.apply(this, arguments);
+    }
+    return changePassword;
+  }()
+};
+exports.default = _default;

package/lib/server/actions/authenticators.d.ts

@@ -0,0 +1,8 @@
+import { Context, Next } from '@nocobase/actions';
+declare const _default: {
+    listTypes: (ctx: Context, next: Next) => Promise<void>;
+    publicList: (ctx: Context, next: Next) => Promise<void>;
+    destroy: (ctx: Context, next: Next) => Promise<void>;
+    update: (ctx: Context, next: Next) => Promise<void>;
+};
+export default _default;

package/lib/server/actions/authenticators.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _preset = require("../../preset");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function checkCount(_x, _x2) {
+  return _checkCount.apply(this, arguments);
+}
+function _checkCount() {
+  _checkCount = _asyncToGenerator(function* (repository, id) {
+    // TODO(yangqia): This is a temporary solution, may cause concurrency problem.
+    const count = yield repository.count({
+      filter: {
+        enabled: true,
+        id: {
+          $ne: id
+        }
+      }
+    });
+    if (count <= 0) {
+      throw new Error('Please keep and enable at least one authenticator');
+    }
+  });
+  return _checkCount.apply(this, arguments);
+}
+var _default = {
+  listTypes: function () {
+    var _listTypes = _asyncToGenerator(function* (ctx, next) {
+      ctx.body = ctx.app.authManager.listTypes();
+      yield next();
+    });
+    function listTypes(_x3, _x4) {
+      return _listTypes.apply(this, arguments);
+    }
+    return listTypes;
+  }(),
+  publicList: function () {
+    var _publicList = _asyncToGenerator(function* (ctx, next) {
+      const repo = ctx.db.getRepository('authenticators');
+      const authenticators = yield repo.find({
+        fields: ['name', 'authType', 'title', 'options', 'sort'],
+        filter: {
+          enabled: true
+        },
+        sort: 'sort'
+      });
+      ctx.body = authenticators.map(authenticator => {
+        var _authenticator$option;
+        return {
+          name: authenticator.name,
+          authType: authenticator.authType,
+          title: authenticator.title,
+          options: ((_authenticator$option = authenticator.options) === null || _authenticator$option === void 0 ? void 0 : _authenticator$option.public) || {}
+        };
+      });
+      yield next();
+    });
+    function publicList(_x5, _x6) {
+      return _publicList.apply(this, arguments);
+    }
+    return publicList;
+  }(),
+  destroy: function () {
+    var _destroy = _asyncToGenerator(function* (ctx, next) {
+      const repository = ctx.db.getRepository('authenticators');
+      const _ctx$action$params = ctx.action.params,
+        filterByTk = _ctx$action$params.filterByTk,
+        filter = _ctx$action$params.filter;
+      try {
+        yield checkCount(repository, filterByTk);
+      } catch (err) {
+        ctx.throw(400, ctx.t(err.message, {
+          ns: _preset.namespace
+        }));
+      }
+      const instance = yield repository.destroy({
+        filter,
+        filterByTk,
+        context: ctx
+      });
+      ctx.body = instance;
+      yield next();
+    });
+    function destroy(_x7, _x8) {
+      return _destroy.apply(this, arguments);
+    }
+    return destroy;
+  }(),
+  update: function () {
+    var _update = _asyncToGenerator(function* (ctx, next) {
+      const repository = ctx.db.getRepository('authenticators');
+      const _ctx$action$params2 = ctx.action.params,
+        forceUpdate = _ctx$action$params2.forceUpdate,
+        filterByTk = _ctx$action$params2.filterByTk,
+        values = _ctx$action$params2.values,
+        whitelist = _ctx$action$params2.whitelist,
+        blacklist = _ctx$action$params2.blacklist,
+        filter = _ctx$action$params2.filter,
+        updateAssociationValues = _ctx$action$params2.updateAssociationValues;
+      if (!values.enabled) {
+        try {
+          yield checkCount(repository, values.id);
+        } catch (err) {
+          ctx.throw(400, ctx.t(err.message, {
+            ns: _preset.namespace
+          }));
+        }
+      }
+      ctx.body = yield repository.update({
+        filterByTk,
+        values,
+        whitelist,
+        blacklist,
+        filter,
+        updateAssociationValues,
+        context: ctx,
+        forceUpdate
+      });
+      yield next();
+    });
+    function update(_x9, _x10) {
+      return _update.apply(this, arguments);
+    }
+    return update;
+  }()
+};
+exports.default = _default;

package/lib/server/basic-auth.d.ts

@@ -0,0 +1,10 @@
+import { AuthConfig, BaseAuth } from '@nocobase/auth';
+export declare class BasicAuth extends BaseAuth {
+    constructor(config: AuthConfig);
+    validate(): Promise<any>;
+    signUp(): Promise<any>;
+    lostPassword(): Promise<any>;
+    resetPassword(): Promise<any>;
+    getUserByResetToken(): Promise<any>;
+    changePassword(): Promise<any>;
+}