@nocobase/plugin-auth 0.10.0-alpha.2

package/src/client/settings/authType.ts

@@ -0,0 +1,18 @@
+import { createContext, useContext } from 'react';
+
+export const AuthTypeContext = createContext<{
+  type: string;
+}>({ type: '' });
+
+export const AuthTypesContext = createContext<{
+  types: {
+    key: string;
+    label: string;
+    value: string;
+  }[];
+}>({ types: [] });
+
+export const useAuthTypes = () => {
+  const { types } = useContext(AuthTypesContext);
+  return types;
+};

package/src/client/settings/schemas/authenticators.ts

@@ -0,0 +1,402 @@
+import { uid } from '@formily/shared';
+import { ISchema } from '@formily/react';
+import { useAPIClient, useActionContext, useRequest } from '@nocobase/client';
+import { useContext } from 'react';
+import { AuthTypeContext } from '../authType';
+import { message } from 'antd';
+import { useTranslation } from 'react-i18next';
+
+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',
+      },
+    },
+  ],
+};
+
+export const createFormSchema: ISchema = {
+  type: 'object',
+  properties: {
+    drawer: {
+      type: 'void',
+      'x-component': 'Action.Drawer',
+      'x-decorator': 'Form',
+      'x-decorator-props': {
+        useValues(options) {
+          const ctx = useActionContext();
+          const { type: authType } = useContext(AuthTypeContext);
+          return useRequest(
+            () =>
+              Promise.resolve({
+                data: {
+                  name: `s_${uid()}`,
+                  authType,
+                },
+              }),
+            { ...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 }}',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+export const authenticatorsSchema: ISchema = {
+  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 = useAPIClient();
+          const { t } = useTranslation();
+          return {
+            async move(from, to) {
+              await api.resource('authenticators').move({
+                sourceId: from.id,
+                targetId: to.id,
+              });
+              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() }}',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};

package/src/index.ts

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

package/src/preset.ts

@@ -0,0 +1,4 @@
+export const presetAuthType = 'Email/Password';
+export const presetAuthenticator = 'basic';
+
+export const namespace = require('../package.json').name;

package/src/server/__tests__/actions.test.ts

@@ -0,0 +1,142 @@
+import Database, { Repository } from '@nocobase/database';
+import { mockServer, MockServer } from '@nocobase/test';
+import AuthPlugin from '../';
+import UsersPlugin from '@nocobase/plugin-users';
+
+describe('actions', () => {
+  describe('authenticators', () => {
+    let app: MockServer;
+    let db: Database;
+    let repo: Repository;
+    let agent;
+
+    beforeAll(async () => {
+      app = mockServer();
+      app.plugin(AuthPlugin);
+      await app.loadAndInstall({ clean: true });
+      db = app.db;
+      repo = db.getRepository('authenticators');
+
+      agent = app.agent();
+    });
+
+    afterEach(async () => {
+      await repo.destroy({
+        truncate: true,
+      });
+    });
+
+    afterAll(async () => {
+      await db.close();
+    });
+
+    it('should list authenticator types', async () => {
+      const res = await agent.resource('authenticators').listTypes();
+      expect(res.body.data).toEqual(['Email/Password']);
+    });
+
+    it('should return enabled authenticators with public options', async () => {
+      await repo.destroy({
+        truncate: true,
+      });
+      await repo.createMany({
+        records: [
+          { name: 'test', authType: 'testType', enabled: true, options: { public: { test: 1 }, private: { test: 2 } } },
+          { name: 'test2', authType: 'testType' },
+        ],
+      });
+      const res = await agent.resource('authenticators').publicList();
+      expect(res.body.data.length).toBe(1);
+      expect(res.body.data[0].name).toBe('test');
+    });
+
+    it('should keep at least one authenticator', async () => {
+      await repo.createMany({
+        records: [{ name: 'test', authType: 'testType', enabled: true }],
+      });
+      const res = await agent.resource('authenticators').destroy();
+      expect(res.statusCode).toBe(400);
+      expect(await repo.count()).toBe(1);
+    });
+
+    it('shoud enable at least one authenticator', async () => {
+      await repo.createMany({
+        records: [{ name: 'test', authType: 'testType', enabled: true }],
+      });
+      const res = await agent.resource('authenticators').update({
+        filterByTk: 1,
+        values: {
+          enabled: false,
+        },
+      });
+      expect(res.statusCode).toBe(400);
+      expect(await repo.count()).toBe(1);
+    });
+  });
+
+  describe('auth', () => {
+    let app: MockServer;
+    let db: Database;
+    let agent;
+
+    beforeAll(async () => {
+      app = mockServer();
+      process.env.INIT_ROOT_EMAIL = 'test@nocobase.com';
+      process.env.INIT_ROOT_PASSWORD = '123456';
+      process.env.INIT_ROOT_NICKNAME = 'Test';
+      app.plugin(AuthPlugin);
+      app.plugin(UsersPlugin, { name: 'users' });
+      await app.loadAndInstall({ clean: true });
+      db = app.db;
+      agent = app.agent();
+    });
+
+    afterAll(async () => {
+      await db.close();
+    });
+
+    it('should sign in with email and password', async () => {
+      let res = await agent.resource('auth').check();
+      expect(res.body.data.id).toBeUndefined();
+
+      res = await agent.post('/auth:signIn').set({ 'X-Authenticator': 'basic' }).send({
+        email: process.env.INIT_ROOT_EMAIL,
+        password: process.env.INIT_ROOT_PASSWORD,
+      });
+      expect(res.statusCode).toEqual(200);
+      const data = res.body.data;
+      const token = data.token;
+      expect(token).toBeDefined();
+
+      res = await agent.get('/auth:check').set({ Authorization: `Bearer ${token}`, 'X-Authenticator': 'basic' });
+      expect(res.body.data.id).toBeDefined();
+    });
+
+    it('should disable sign up', async () => {
+      let res = await agent.post('/auth:signUp').set({ 'X-Authenticator': 'basic' }).send({
+        email: 'new',
+        password: 'new',
+      });
+      expect(res.statusCode).toEqual(200);
+
+      const repo = db.getRepository('authenticators');
+      await repo.update({
+        filter: {
+          name: 'basic',
+        },
+        values: {
+          options: {
+            public: {
+              allowSignUp: false,
+            },
+          },
+        },
+      });
+      res = await agent.post('/auth:signUp').set({ 'X-Authenticator': 'basic' }).send({
+        email: process.env.INIT_ROOT_EMAIL,
+        password: process.env.INIT_ROOT_PASSWORD,
+      });
+      expect(res.statusCode).toEqual(403);
+    });
+  });
+});

package/src/server/actions/auth.ts

@@ -0,0 +1,20 @@
+import { Context, Next } from '@nocobase/actions';
+
+export default {
+  lostPassword: async (ctx: Context, next: Next) => {
+    ctx.body = await ctx.auth.lostPassword();
+    await next();
+  },
+  resetPassword: async (ctx: Context, next: Next) => {
+    ctx.body = await ctx.auth.resetPassword();
+    await next();
+  },
+  getUserByResetToken: async (ctx: Context, next: Next) => {
+    ctx.body = await ctx.auth.getUserByResetToken();
+    await next();
+  },
+  changePassword: async (ctx: Context, next: Next) => {
+    ctx.body = await ctx.auth.changePassword();
+    await next();
+  },
+};

package/src/server/actions/authenticators.ts

@@ -0,0 +1,85 @@
+import { Context, Next } from '@nocobase/actions';
+import { namespace } from '../../preset';
+import { Model, Repository } from '@nocobase/database';
+
+async function checkCount(repository: Repository, id: number) {
+  // TODO(yangqia): This is a temporary solution, may cause concurrency problem.
+  const count = await repository.count({
+    filter: {
+      enabled: true,
+      id: {
+        $ne: id,
+      },
+    },
+  });
+  if (count <= 0) {
+    throw new Error('Please keep and enable at least one authenticator');
+  }
+}
+
+export default {
+  listTypes: async (ctx: Context, next: Next) => {
+    ctx.body = ctx.app.authManager.listTypes();
+    await next();
+  },
+  publicList: async (ctx: Context, next: Next) => {
+    const repo = ctx.db.getRepository('authenticators');
+    const authenticators = await repo.find({
+      fields: ['name', 'authType', 'title', 'options', 'sort'],
+      filter: {
+        enabled: true,
+      },
+      sort: 'sort',
+    });
+    ctx.body = authenticators.map((authenticator: Model) => ({
+      name: authenticator.name,
+      authType: authenticator.authType,
+      title: authenticator.title,
+      options: authenticator.options?.public || {},
+    }));
+    await next();
+  },
+  destroy: async (ctx: Context, next: Next) => {
+    const repository = ctx.db.getRepository('authenticators');
+    const { filterByTk, filter } = ctx.action.params;
+    try {
+      await checkCount(repository, filterByTk);
+    } catch (err) {
+      ctx.throw(400, ctx.t(err.message, { ns: namespace }));
+    }
+    const instance = await repository.destroy({
+      filter,
+      filterByTk,
+      context: ctx,
+    });
+
+    ctx.body = instance;
+    await next();
+  },
+  update: async (ctx: Context, next: Next) => {
+    const repository = ctx.db.getRepository('authenticators');
+    const { forceUpdate, filterByTk, values, whitelist, blacklist, filter, updateAssociationValues } =
+      ctx.action.params;
+
+    if (!values.enabled) {
+      try {
+        await checkCount(repository, values.id);
+      } catch (err) {
+        ctx.throw(400, ctx.t(err.message, { ns: namespace }));
+      }
+    }
+
+    ctx.body = await repository.update({
+      filterByTk,
+      values,
+      whitelist,
+      blacklist,
+      filter,
+      updateAssociationValues,
+      context: ctx,
+      forceUpdate,
+    });
+
+    await next();
+  },
+};