@adminforth/open-signup 1.0.0

package/dist/custom/SignupPage.vue

@@ -0,0 +1,337 @@
+<template>
+  <div class="relative flex items-center justify-center min-h-screen bg-gray-100 dark:bg-gray-800 relative w-screen h-screen"
+    :style="coreStore.config?.loginBackgroundImage && backgroundPosition === 'over' ? {
+      'background-image': 'url(' + loadFile(coreStore.config?.loginBackgroundImage) + ')',
+      'background-size': 'cover',
+      'background-position': 'center',
+      'background-blend-mode': 'darken'
+    }: {}"
+  >
+    
+    <img v-if="coreStore.config?.loginBackgroundImage && backgroundPosition !== 'over'"
+      :src="loadFile(coreStore.config?.loginBackgroundImage)"
+      class="position-absolute top-0 left-0 h-screen object-cover w-0"
+      :class="{
+        '1/2': 'md:w-1/2',
+        '1/3': 'md:w-1/3',
+        '2/3': 'md:w-2/3',
+        '3/4': 'md:w-3/4',
+        '2/5': 'md:w-2/5',
+        '3/5': 'md:w-3/5',
+      }[backgroundPosition]"
+    />
+
+    <!-- Main modal -->
+    <div id="authentication-modal" tabindex="-1" 
+      class="overflow-y-auto flex flex-grow
+      overflow-x-hidden z-50 min-w-[350px]  justify-center items-center md:inset-0 h-[calc(100%-1rem)] max-h-full">
+        <div class="relative p-4 w-full max-h-full max-w-[400px]">
+            <!-- Modal content -->
+            <div class="relative bg-white rounded-lg shadow dark:bg-gray-700 dark:shadow-black" >
+                <!-- Modal header -->
+                <div class="flex items-center justify-between p-4 md:p-5 border-b rounded-t dark:border-gray-600">
+                    <h3 class="text-xl font-semibold text-gray-900 dark:text-white">
+                      {{$t('Sign up into')}} {{ coreStore.config?.brandName }}
+                    </h3>
+                </div>
+                <!-- Modal body -->
+                <div class="p-4 md:p-5">
+                  <form v-if="!requestSent" class="space-y-4" role="alert" @submit.prevent>
+                    <div v-if="!verifyToken" class="relative">
+                      <label for="email" class="block mb-2 text-sm font-medium text-gray-900 dark:text-white">{{$t('Your email address')}}</label>
+                      <input type="email" name="email" id="email" 
+                        tabindex="1"
+                        autocomplete="username"  
+                        @keydown.enter="passwordInput?.focus()"
+                        ref="emailInput"
+                        class="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-blue-500 focus:border-blue-500 block w-full p-2.5 dark:bg-gray-600 dark:border-gray-500 dark:placeholder-gray-400 dark:text-white" 
+                        placeholder="name@company.com" 
+                        required
+                      />
+                    </div>
+                    <div v-if="isPasswordNeeded" class="relative">
+                      <label for="password" class="block mb-2 text-sm font-medium text-gray-900 dark:text-white">{{$t('Your password')}}</label>
+                      <input 
+                        tabindex="2"
+                        autocomplete="new-password"
+                        ref="passwordInput"
+                        :type="unmasked ? 'text' : 'password'"
+                        name="password" id="password" 
+                        v-model="password"
+                        @keydown.enter="passwordConfirmationInput?.focus()"
+                        class="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-blue-500 focus:border-blue-500 block w-full p-2.5 dark:bg-gray-600 dark:border-gray-500 dark:placeholder-gray-400 dark:text-white" 
+                        :placeholder="$t('New password')" required 
+                      />
+                      
+                      <button
+                        type="button"
+                        @click="unmasked = !unmasked"
+                        class="h-6 absolute inset-y-2 top-9 right-1 flex items-center pr-2 z-index-100 focus:outline-none"
+                      >
+                        <IconEyeSolid class="w-6 h-6 text-gray-400"  v-if="!unmasked" />
+                        <IconEyeSlashSolid class="w-6 h-6 text-gray-400" v-else />
+                      </button>
+                    </div>
+
+                    <div v-if="isPasswordNeeded" class="relative">
+                      <label for="password_confirmation" class="block mb-2 text-sm font-medium text-gray-900 dark:text-white">{{$t('Confirm your password')}}</label>
+                      <input 
+                        ref="passwordConfirmationInput"
+                        autocomplete="new-password"
+                        :type="unmasked ? 'text' : 'password'"
+                        name="password_confirmation" id="password_confirmation" 
+                        tabindex="3"
+                        v-model="passwordConfirmation"
+                        class="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-blue-500 focus:border-blue-500 block w-full p-2.5 dark:bg-gray-600 dark:border-gray-500 dark:placeholder-gray-400 dark:text-white" 
+                        :placeholder="$t('Confirm new password')" required 
+                      />
+
+                      <button
+                        type="button"
+                        @click="unmasked = !unmasked"
+                        class="h-6 absolute inset-y-2 top-9 right-1 flex items-center pr-2 z-index-100 focus:outline-none"
+                      >
+                        <IconEyeSolid class="w-6 h-6 text-gray-400"  v-if="!unmasked" />
+                        <IconEyeSlashSolid class="w-6 h-6 text-gray-400" v-else />
+                      </button>
+                    </div>
+
+                    <div v-if="validationError || error" class="flex items-center p-4 mb-4 text-sm text-red-800 rounded-lg bg-red-50 dark:bg-gray-800 dark:text-red-400" role="alert">
+                      <svg class="flex-shrink-0 inline w-4 h-4 me-3" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="currentColor" viewBox="0 0 20 20">
+                        <path d="M10 .5a9.5 9.5 0 1 0 9.5 9.5A9.51 9.51 0 0 0 10 .5ZM9.5 4a1.5 1.5 0 1 1 0 3 1.5 1.5 0 0 1 0-3ZM12 15H8a1 1 0 0 1 0-2h1v-3H8a1 1 0 0 1 0-2h2a1 1 0 0 1 1 1v4h1a1 1 0 0 1 0 2Z"/>
+                      </svg>
+                      <span class="sr-only">{{$t('Info')}}</span>
+                      <div>
+                        {{ validationError || error }}
+                      </div>
+                    </div>
+
+                    <Button
+                      :disabled="inProgress || (validationRunning && validationError)"
+                      @click="() => verifyToken ? signupAfterEmailConfirmation() : doSignup()"
+                      type="submit"
+                      class="w-full"
+                      :loader="inProgress"
+                    >
+                      {{$t('Sign up')}}
+                    </Button>
+                  </form>
+<!-- END of set new paasord -->
+                  <div v-else class="flex items center justify-center p-4 mb-4 text-sm text-green-800 rounded-lg bg-green-50 dark:bg-green-800 dark:text-green-400" role="alert">
+                    {{$t('Please check your email at')}} {{ sentToEmail }} {{$t('to confirm your email address.')}}
+                  </div> 
+                  <p class="text-gray-500 dark:text-gray-400 font-sm text-right mt-3">
+                      {{$t('Already have an account?')}} <Link :to="`/login${route.query.next ? `?next=${encodeURIComponent(route.query.next)}` : ''}`">{{ $t('login here') }}</Link>
+                  </p>
+                </div>
+            </div>
+        </div>
+    </div> 
+
+  </div>
+</template>
+
+
+<script setup lang="ts">
+import { onMounted, ref, computed, Ref, onBeforeMount, nextTick } from 'vue';
+import { useCoreStore } from '@/stores/core';
+import { useUserStore } from '@/stores/user';
+import { callAdminForthApi, loadFile, applyRegexValidation } from '@/utils';
+import { onBeforeRouteUpdate, useRoute, useRouter } from 'vue-router';
+import { IconEyeSolid, IconEyeSlashSolid } from '@iconify-prerendered/vue-flowbite';
+import Button from '@/afcl/Button.vue';
+import Link from '@/afcl/Link.vue';
+import { useI18n } from 'vue-i18n';
+import adminforth from '@/adminforth';
+
+const { t } = useI18n();
+
+const inProgress = ref(false);
+
+const coreStore = useCoreStore();
+const requestSent = ref(false);
+
+const emailInput: Ref<HTMLInputElement | null> = ref(null);
+const passwordInput: Ref<HTMLInputElement | null> = ref(null);
+const passwordConfirmationInput: Ref<HTMLInputElement | null> = ref(null);
+
+const password = ref("");
+const passwordConfirmation = ref("");
+const unmasked = ref(false);
+const sentToEmail: Ref<string> = ref('');
+
+const requestEmailConfirmation = computed(() => route.meta.requestEmailConfirmation);
+const verifyToken = computed(() => route.query.token);
+const isPasswordNeeded = computed(() => !requestEmailConfirmation.value || (requestEmailConfirmation.value && verifyToken.value));
+
+const user = useUserStore();
+
+const route = useRoute();
+const router = useRouter();
+
+function checkPassword() {
+
+  if (!password.value || !passwordConfirmation.value) {
+    return t('Please enter both password and password confirmation');
+  }
+  if (password.value !== passwordConfirmation.value) {
+    return t('Passwords do not match');
+  }
+
+  if (!passwordConstraints.value) {
+    return null;
+  }
+  if (password.value.length < passwordConstraints.value.minLength) {
+    return t(`Password must be at least {minLength} characters long`, { minLength: passwordConstraints.value.minLength });
+  }
+
+  if (password.value.length > passwordConstraints.value.maxLength) {
+    return t(`Password must be at most {maxLength} characters long`, { maxLength: passwordConstraints.value.maxLength });
+  }
+
+  if (passwordConstraints.value.validation) {
+    const valError = applyRegexValidation(password.value, passwordConstraints.value.validation);
+    if (valError) {
+      return valError;
+    }
+  }
+
+  return null;
+}
+
+const validationRunning = ref(false);
+
+const validationError = computed(() => {
+  if (validationRunning.value) {
+    return checkPassword();
+  }
+  return null;
+});
+
+const error: Ref<string | null> = ref(null);
+
+
+const backgroundPosition = computed(() => {
+  return coreStore.config?.loginBackgroundPosition || '1/2';
+});
+
+
+const passwordConstraints: Ref<{
+  minLength: number;
+  maxLength: number;
+  validation: string;
+}> = ref({
+  minLength: 8,
+  maxLength: 100,
+  validation: '',
+});
+
+// implement something similar to beforeEnter
+// beforeEnter: async (to, from, next) => {
+//         if(localStorage.getItem('isAuthorized') === 'true') {
+//           // check if url has next=... and redirect to it
+//           console.log('to.query', to.query)
+//           if (to.query.next) {
+//             next(to.query.next.toString())
+//           } else {
+//             next({name: 'home'});
+//           }
+//         } else {
+//           next()
+//         }
+//       } 
+
+onBeforeMount(() => {
+  // console.log('⛔ SignUp Page. Before Mount: ', route)
+  if (localStorage.getItem('isAuthorized') === 'true') {
+    // if route has next param, redirect
+    coreStore.fetchMenuAndResource();
+    if (route.query.next) {
+      router.push(route.query.next.toString());
+    } else {
+      router.push({ name: 'home' });
+    }
+  }
+})
+
+onMounted(async () => {
+  emailInput.value?.focus();
+  await coreStore.getPublicConfig();
+
+  await nextTick();
+  await router.isReady();
+
+  // getPasswordConstraints
+  console.log('⛔ SignUp Page. Before Mount: ', route.meta)
+  passwordConstraints.value = await callAdminForthApi({
+    path: `/plugin/${route.meta.pluginInstanceId}/password-constraints`,
+    method: 'GET',
+  });
+})
+
+// onMounted(async () => {
+// });
+
+async function doSignup() {
+  error.value = null;
+  const email = emailInput.value!.value;
+  if (!email) {
+    error.value = t('Please enter your email');
+    return;
+  }
+  if (!requestEmailConfirmation.value && checkPassword()) {
+    validationRunning.value = true;
+    return;
+  }
+
+  inProgress.value = true;
+  const resp = await callAdminForthApi({
+    path: `/plugin/${route.meta.pluginInstanceId}/signup`,
+    method: 'POST',
+    body: {
+      email,
+      url: window.location.origin + window.location.pathname,
+      ...(!requestEmailConfirmation.value ? {password: password.value} : {}),
+    }
+  });
+  inProgress.value = false;
+  if (resp.error) {
+    error.value = resp.error;
+  } else {
+    error.value = null;
+    requestSent.value = true;
+    sentToEmail.value = email;
+    if (resp.redirectTo && !requestEmailConfirmation.value) {
+      router.push(resp.redirectTo);
+    } else if (!requestEmailConfirmation.value) {
+      error.value = null;
+      await user.finishLogin();
+    }
+  }
+}
+
+const signupAfterEmailConfirmation = async () => {
+  if (checkPassword()) {
+    validationRunning.value = true;
+    return;
+  }
+  const resp = await callAdminForthApi({
+      path: `/plugin/${route.meta.pluginInstanceId}/complete-verified-signup`,
+      method: 'POST',
+      body: {
+        token: verifyToken.value,
+        password: password.value,
+      }
+    });
+    if (resp.error) {
+      adminforth.alert({
+        message: t(`Error fetching data: {error}`, { error: resp.error }),
+        variant: 'danger',
+      });
+    } else if (resp.redirectTo) {
+      router.push(resp.redirectTo);
+    } else {
+      await user.finishLogin();
+    }
+}
+</script>

package/dist/custom/SignupUnderLogin.vue

@@ -0,0 +1,16 @@
+<template>
+  <p class="text-gray-500 dark:text-gray-400 font-sm text-left mt-3">
+    {{$t('Have no account?')}} 
+    <Link :to="`/signup${route.query.next ? `?next=${encodeURIComponent(route.query.next)}` : ''}`">
+      {{$t('sign up now')}}
+    </Link>
+  </p>
+</template>
+
+<script setup>
+import Link from '@/afcl/Link.vue';
+import { useRoute } from 'vue-router';
+
+const route = useRoute();
+
+</script>

package/dist/custom/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".", // This should point to your project root
+    "paths": {
+      "@/*": [
+        // "node_modules/adminforth/dist/spa/src/*"
+        "../../../spa/src/*"
+      ],
+      "*": [
+        // "node_modules/adminforth/dist/spa/node_modules/*"
+        "../../../spa/node_modules/*"
+      ],
+      "@@/*": [
+        // "node_modules/adminforth/dist/spa/src/*"
+        "."
+      ]
+    }
+  }
+}

package/dist/index.js

@@ -0,0 +1,291 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import AdminForth, { AdminForthPlugin, Filters, suggestIfTypo, AdminForthDataTypes } from "adminforth";
+export default class OpenSignupPlugin extends AdminForthPlugin {
+    constructor(options) {
+        super(options, import.meta.url);
+        this.options = options;
+    }
+    modifyResourceConfig(adminforth, resourceConfig) {
+        const _super = Object.create(null, {
+            modifyResourceConfig: { get: () => super.modifyResourceConfig }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.modifyResourceConfig.call(this, adminforth, resourceConfig);
+            if (!this.options.emailField) {
+                throw new Error(`emailField is required and should be a name of field in auth resource`);
+            }
+            // find field with name resourceConfig.emailField in adminforth.auth.usersResourceId and show error if it doesn't exist
+            const authResource = adminforth.config.resources.find(r => r.resourceId === adminforth.config.auth.usersResourceId);
+            if (!authResource) {
+                throw new Error(`Resource with id config.auth.usersResourceId=${adminforth.config.auth.usersResourceId} not found`);
+            }
+            this.authResource = authResource;
+            if (this.options.confirmEmails) {
+                if (!this.options.confirmEmails.adapter) {
+                    throw new Error(`confirmEmails.adapter is required and should be a name of field in auth resource`);
+                }
+                if (!this.options.confirmEmails.emailConfirmedField) {
+                    throw new Error(`confirmEmails.emailConfirmedField is required and should be a name of field in auth resource`);
+                }
+                const emailConfirmedField = this.authResource.columns.find(f => f.name === this.options.confirmEmails.emailConfirmedField);
+                if (!emailConfirmedField) {
+                    const similar = suggestIfTypo(this.authResource.columns.map(f => f.name), this.options.confirmEmails.emailConfirmedField);
+                    throw new Error(`Field with name ${this.options.confirmEmails.emailConfirmedField} not found in resource ${this.authResource.resourceId}.
+          ${similar ? `Did you mean ${similar}?` : ''}
+        `);
+                }
+                this.emailConfirmedField = emailConfirmedField;
+            }
+            const emailField = authResource.columns.find(f => f.name === this.options.emailField);
+            if (!emailField) {
+                const similar = suggestIfTypo(authResource.columns.map(f => f.name), this.options.emailField);
+                throw new Error(`Field with name ${this.options.emailField} not found in resource ${authResource.resourceId}.
+        ${similar ? `Did you mean ${similar}?` : ''}
+      `);
+            }
+            this.emailField = emailField;
+            if (!this.options.passwordField) {
+                throw new Error(`passwordField is required to get password constraints and should be a name of virtual field in auth resource`);
+            }
+            const passwordField = authResource.columns.find(f => f.name === this.options.passwordField);
+            if (!passwordField) {
+                const similar = suggestIfTypo(authResource.columns.map(f => f.name), this.options.passwordField);
+                throw new Error(`Field with name ${this.options.passwordField} not found in resource ${authResource.resourceId}.
+        ${similar ? `Did you mean ${similar}?` : ''}
+      `);
+            }
+            this.passwordField = passwordField;
+            adminforth.config.customization.loginPageInjections.underInputs.push({
+                file: this.componentPath('SignupUnderLogin.vue'),
+            });
+            adminforth.config.customization.customPages.push({
+                path: '/signup',
+                component: {
+                    file: this.componentPath('SignupPage.vue'),
+                    meta: {
+                        customLayout: true,
+                        pluginInstanceId: this.pluginInstanceId,
+                        requestEmailConfirmation: !!this.options.confirmEmails
+                    }
+                }
+            });
+            // for confirmation disable login if email is not confirmed
+            if (this.options.confirmEmails) {
+                if (!adminforth.config.auth.beforeLoginConfirmation) {
+                    adminforth.config.auth.beforeLoginConfirmation = [];
+                }
+            }
+        });
+    }
+    validateConfigAfterDiscover(adminforth, resourceConfig) {
+        if (this.options.confirmEmails) {
+            this.options.confirmEmails.adapter.validate();
+        }
+        if (this.options.confirmEmails) {
+            const emailConfirmedColumn = this.resourceConfig.columns.find(f => f.name === this.options.confirmEmails.emailConfirmedField);
+            if (emailConfirmedColumn.type !== AdminForthDataTypes.BOOLEAN) {
+                throw new Error(`Field ${this.emailConfirmedField.name} must be of type boolean`);
+            }
+        }
+    }
+    instanceUniqueRepresentation(pluginOptions) {
+        // optional method to return unique string representation of plugin instance. 
+        // Needed if plugin can have multiple instances on one resource 
+        return `single`;
+    }
+    doLogin(email, response, extra) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const username = email;
+            const userRecord = yield this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, email));
+            const adminUser = {
+                dbUser: userRecord,
+                pk: userRecord[this.authResource.columns.find((col) => col.primaryKey).name],
+                username,
+            };
+            const toReturn = { allowedLogin: true, error: '' };
+            yield this.adminforth.restApi.processLoginCallbacks(adminUser, toReturn, response, extra);
+            if (toReturn.allowedLogin) {
+                this.adminforth.auth.setAuthCookie({
+                    response,
+                    username,
+                    pk: userRecord[this.authResource.columns.find((col) => col.primaryKey).name]
+                });
+            }
+            return toReturn;
+        });
+    }
+    setupEndpoints(server) {
+        server.endpoint({
+            method: 'GET',
+            path: `/plugin/${this.pluginInstanceId}/password-constraints`,
+            noAuth: true,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ tr }) {
+                return {
+                    minLength: this.passwordField.minLength,
+                    maxLength: this.passwordField.maxLength,
+                    validation: yield Promise.all(this.passwordField.validation.map((_a) => __awaiter(this, [_a], void 0, function* ({ regExp, message }) { return ({ regExp, message: yield tr(message, 'opensignup') }); }))),
+                };
+            })
+        });
+        server.endpoint({
+            method: 'POST',
+            path: `/plugin/${this.pluginInstanceId}/complete-verified-signup`,
+            noAuth: true,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response, headers, query, cookies, tr, requestUrl }) {
+                const { token, password } = body;
+                const { email } = yield this.adminforth.auth.verify(token, 'tempVerifyEmailToken', false);
+                if (!email) {
+                    return { error: 'Invalid token', ok: false };
+                }
+                if (!password) {
+                    return { error: tr('Password is required', 'opensignup'), ok: false };
+                }
+                const userRecord = yield this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, email));
+                if (!userRecord) {
+                    return { error: tr('User not found'), ok: false };
+                }
+                if (userRecord[this.options.confirmEmails.emailConfirmedField]) {
+                    return { error: tr('Email already confirmed'), ok: false };
+                }
+                yield this.adminforth.resource(this.authResource.resourceId).update(userRecord[this.authResource.columns.find((col) => col.primaryKey).name], {
+                    [this.options.confirmEmails.emailConfirmedField]: true,
+                    [this.options.passwordHashField]: yield AdminForth.Utils.generatePasswordHash(password),
+                });
+                return yield this.doLogin(email, response, { body, headers, query, cookies, requestUrl });
+            })
+        });
+        server.endpoint({
+            method: 'POST',
+            path: `/plugin/${this.pluginInstanceId}/signup`,
+            noAuth: true,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response, headers, query, cookies, tr, requestUrl }) {
+                var _b, _c;
+                const { email, url, password } = body;
+                const extra = { body, headers, query, cookies, requestUrl: url };
+                // validate email
+                if (this.emailField.validation) {
+                    for (const { regExp, message } of this.emailField.validation) {
+                        if (!new RegExp(regExp).test(email)) {
+                            return { error: yield tr(message, 'opensignup'), ok: false };
+                        }
+                    }
+                }
+                // validate password
+                if (!this.options.confirmEmails) {
+                    if (password.length < this.passwordField.minLength) {
+                        return {
+                            error: yield tr(`Password must be at least ${this.passwordField.minLength} characters long`, 'opensignup'),
+                            ok: false
+                        };
+                    }
+                    if (password.length > this.passwordField.maxLength) {
+                        return {
+                            error: yield tr(`Password must be at most ${this.passwordField.maxLength} characters long`, 'opensignup'),
+                            ok: false
+                        };
+                    }
+                    if (this.passwordField.validation) {
+                        for (const { regExp, message } of this.passwordField.validation) {
+                            if (!new RegExp(regExp).test(password)) {
+                                return { error: yield tr(message, 'opensignup'), ok: false };
+                            }
+                        }
+                    }
+                }
+                // This is not needed when right email validator is set on email field because
+                // it will not allow to create such email, but if user forgot to set it it might save situation 
+                const normalizedEmail = email.toLowerCase(); // normalize email
+                // first check again if email already exists
+                const existingUser = yield this.adminforth.resource(this.authResource.resourceId).get(Filters.EQ(this.emailField.name, normalizedEmail));
+                if ((!this.options.confirmEmails && existingUser) || (this.options.confirmEmails && (existingUser === null || existingUser === void 0 ? void 0 : existingUser[this.emailConfirmedField.name]))) {
+                    return { error: yield tr(`Email already exists`, 'opensignup'), ok: false };
+                }
+                // create user
+                if (!existingUser) {
+                    if ((_b = this.options.hooks) === null || _b === void 0 ? void 0 : _b.beforeUserSave) {
+                        const hook = this.options.hooks.beforeUserSave;
+                        const recordToCreate = Object.assign(Object.assign(Object.assign({}, (this.options.defaultFieldValues || {})), (this.options.confirmEmails ? { [this.options.confirmEmails.emailConfirmedField]: false } : {})), { [this.emailField.name]: normalizedEmail, [this.options.passwordHashField]: password ? yield AdminForth.Utils.generatePasswordHash(password) : '' });
+                        const resp = yield hook({
+                            resource: this.authResource,
+                            record: recordToCreate,
+                            adminforth: this.adminforth,
+                            extra,
+                        });
+                        if (!resp || (!resp.ok && !resp.error)) {
+                            throw new Error(`Hook beforeUserSave must return object with {ok: true} or { error: 'Error' } `);
+                        }
+                        if (resp.error) {
+                            return { error: resp.error };
+                        }
+                    }
+                    const created = yield this.adminforth.resource(this.authResource.resourceId).create(Object.assign(Object.assign(Object.assign({}, (this.options.defaultFieldValues || {})), (this.options.confirmEmails ? { [this.options.confirmEmails.emailConfirmedField]: false } : {})), { [this.emailField.name]: normalizedEmail, [this.options.passwordHashField]: password ? yield AdminForth.Utils.generatePasswordHash(password) : '' }));
+                    if ((_c = this.options.hooks) === null || _c === void 0 ? void 0 : _c.afterUserSave) {
+                        const hook = this.options.hooks.afterUserSave;
+                        const resp = yield hook({
+                            resource: this.authResource,
+                            record: created,
+                            adminforth: this.adminforth,
+                            extra,
+                        });
+                        if (!resp || (!resp.ok && !resp.error)) {
+                            throw new Error(`Hook afterUserSave must return object with {ok: true} or { error: 'Error' } `);
+                        }
+                        if (resp.error) {
+                            return { error: resp.error };
+                        }
+                    }
+                }
+                if (!this.options.confirmEmails) {
+                    const resp = yield this.doLogin(email, response, { body, headers, query, cookies, requestUrl });
+                    return resp;
+                }
+                // send confirmation email
+                const brandName = this.adminforth.config.customization.brandName;
+                const verifyToken = this.adminforth.auth.issueJWT({ email, issuer: brandName }, 'tempVerifyEmailToken', '2h');
+                process.env.HEAVY_DEBUG && console.log('🐛Sending reset tok to', verifyToken);
+                const emailText = tr(`
+                  Dear user,
+                  Welcome to {brandName}! 
+                  
+                  To confirm your email, click the link below:\n\n
+
+                  {url}?verifyToken={verifyToken}\n\n
+
+                  If you didn't request this, please ignore this email.\n\n
+                  Link is valid for 2 hours.\n\n
+
+                  Thanks,
+                  The {brandName} Team
+                                    
+                `, 'opensignup', { brandName, url, verifyToken });
+                const emailHtml = tr(`
+              <html>
+                <head></head>
+                <body>
+                  <p>Dear user,</p>
+                  <p>Welcome to {brandName}!</p>
+                  <p>To confirm your email, click the link below:</p>
+                  <a href="{url}?token={verifyToken}">Confirm email</a>
+                  <p>If you didn't request this, please ignore this email.</p>
+                  <p>Link is valid for 2 hours.</p>
+                  <p>Thanks,</p>
+                  <p>The {brandName} Team</p>
+                </body>
+              </html>
+        `, 'opensignup', { brandName, url, verifyToken });
+                const emailSubject = tr(`Signup request at {brandName}`, 'opensignup', { brandName });
+                // send email with AWS SES this.options.providerOptions.AWS_SES
+                this.options.confirmEmails.adapter.sendEmail(this.options.confirmEmails.sendFrom, email, emailText, emailHtml, emailSubject);
+                return { ok: true };
+            })
+        });
+    }
+}

package/dist/types.js

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