firstly 0.0.6 → 0.0.8

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # firstly
 
+## 0.0.8
+
+### Patch Changes
+
+- [#27](https://github.com/jycouet/firstly/pull/27)
+  [`66711b2`](https://github.com/jycouet/firstly/commit/66711b2373c69006d7ae5f06d8f4a6cb0e43670b)
+  Thanks [@jycouet](https://github.com/jycouet)! - fix the session creation on signIn! (+default
+  expiration is 30 days)
+
+- [#27](https://github.com/jycouet/firstly/pull/27)
+  [`0657c5c`](https://github.com/jycouet/firstly/commit/0657c5ca8b81673b493a6815a196a8c5351ecdf0)
+  Thanks [@jycouet](https://github.com/jycouet)! - add uiStaticPath option in auth module to
+  overwrite where are the static files for the module (dev option)
+
+## 0.0.7
+
+### Patch Changes
+
+- [#25](https://github.com/jycouet/firstly/pull/25)
+  [`54f2f6a`](https://github.com/jycouet/firstly/commit/54f2f6a833c1977c3163e91ce3172fa8edc9da47)
+  Thanks [@jycouet](https://github.com/jycouet)! - adding e2e tests for accounts
+
+- [#25](https://github.com/jycouet/firstly/pull/25)
+  [`943e9d0`](https://github.com/jycouet/firstly/commit/943e9d0b6d5d6a631dc78661d188a76f254d4632)
+  Thanks [@jycouet](https://github.com/jycouet)! - rename name to identifier in db
+
 ## 0.0.6
 
 ### Patch Changes

package/esm/FF_Entity.js

@@ -1,4 +1,5 @@
 import { Entity } from 'remult';
+import { recordDeleted, recordSaved } from './changeLog';
 const toAllow = (permission) => {
     if (permission) {
         if (Array.isArray(permission)) {
@@ -16,9 +17,24 @@ export function FF_Entity(key, options) {
         allowApiInsert: options.allowApiInsert ?? toAllow(options.permissionApiInsert),
         allowApiRead: options.allowApiRead ?? toAllow(options.permissionApiRead),
         allowApiUpdate: options.allowApiUpdate ?? toAllow(options.permissionApiUpdate),
-        // saved: async (item, e) => {
-        //   console.log('was saved')
-        //   await options?.saved?.(item, e)
-        // },
+        // changesLogs
+        saved: async (entity, e) => {
+            await options?.saved?.(entity, e);
+            if (options.changeLog === false) {
+                // Don't log changes
+            }
+            else {
+                await recordSaved(entity, e, options.changeLog);
+            }
+        },
+        deleted: async (entity, e) => {
+            await options?.deleted?.(entity, e);
+            if (options.changeLog === false) {
+                // Don't log changes
+            }
+            else {
+                await recordDeleted(entity, e, options.changeLog);
+            }
+        },
     });
 }

package/esm/ROUTES.d.ts

@@ -32,16 +32,16 @@ declare const AllObjs: {
         repo?: (string | number);
     }) => string;
     "/": string;
+    "/auth": string;
     "/mail": string;
-    "/remult": string;
-    "/remult/auth": string;
-    "/remult/enum": string;
-    "/remult/select": string;
-    "/ui": string;
+    "/ui/dialog": string;
+    "/ui/enum": string;
+    "/ui/fieldGroup": string;
+    "/ui/select": string;
 };
 type AllTypes = typeof AllObjs;
 export type Routes = keyof AllTypes extends `${string}/${infer Route}` ? `/${Route}` : keyof AllTypes;
-export declare const routes: ("/" | "/mail" | "/remult" | "/remult/auth" | "/remult/enum" | "/remult/select" | "/ui" | "firstly_sign_in" | "remult_admin" | "github")[];
+export declare const routes: ("/" | "/auth" | "/mail" | "/ui/dialog" | "/ui/enum" | "/ui/fieldGroup" | "/ui/select" | "firstly_sign_in" | "remult_admin" | "github")[];
 /**
  * To be used like this:
  * ```ts
@@ -70,12 +70,12 @@ export declare function route<T extends NonFunctionKeys<AllTypes>>(key: T): stri
 export type KIT_ROUTES = {
     PAGES: {
         '/': never;
+        '/auth': never;
         '/mail': never;
-        '/remult': never;
-        '/remult/auth': never;
-        '/remult/enum': never;
-        '/remult/select': never;
-        '/ui': never;
+        '/ui/dialog': never;
+        '/ui/enum': never;
+        '/ui/fieldGroup': never;
+        '/ui/select': never;
     };
     SERVERS: Record<string, never>;
     ACTIONS: Record<string, never>;

package/esm/ROUTES.js

@@ -9,12 +9,12 @@
  */
 const PAGES = {
     "/": `/`,
+    "/auth": `/auth`,
     "/mail": `/mail`,
-    "/remult": `/remult`,
-    "/remult/auth": `/remult/auth`,
-    "/remult/enum": `/remult/enum`,
-    "/remult/select": `/remult/select`,
-    "/ui": `/ui`
+    "/ui/dialog": `/ui/dialog`,
+    "/ui/enum": `/ui/enum`,
+    "/ui/fieldGroup": `/ui/fieldGroup`,
+    "/ui/select": `/ui/select`
 };
 /**
  * SERVERS

package/esm/SqlDatabase/FF_LogToConsole.d.ts

@@ -1 +1,4 @@
-export declare const FF_LogToConsole: (duration: number, query: string, args: Record<string, any>, short?: boolean) => string | undefined;
+export declare const FF_LogToConsole: (duration: number, query: string, args: Record<string, any>, options?: {
+    withDetails?: boolean;
+    tablesToHide?: string[][];
+}) => string | undefined;

package/esm/SqlDatabase/FF_LogToConsole.js

@@ -16,7 +16,7 @@ const typeQuery = new Map([
 ]);
 const keys = ['FROM', 'WHERE', 'LIMIT', 'OFFSET'];
 const typeQueryKey = Array.from(typeQuery.keys());
-export const FF_LogToConsole = (duration, query, args, short = true) => {
+export const FF_LogToConsole = (duration, query, args, options) => {
     const rawSql = query
         .replace(/(\r\n|\n|\r|\t)/gm, ' ')
         .replace(/  +/g, ' ')
@@ -79,7 +79,10 @@ export const FF_LogToConsole = (duration, query, args, short = true) => {
     const subTables = uniqueTables.slice(0, -1);
     const time = ` ${bgCyan((duration * 1000).toFixed(0).padStart(3) + ' ms ')}`;
     let toLog = '';
-    if (short) {
+    if (options?.withDetails) {
+        toLog = `${typeQuery.get(first) || '💢'}` + time + ` ${final_s}`;
+    }
+    else {
         toLog =
             `${typeQuery.get(first) || '💢'}` +
                 `${time}` +
@@ -87,12 +90,16 @@ export const FF_LogToConsole = (duration, query, args, short = true) => {
                 `${listArgs.length > 0 ? ` { ${listArgs.join(', ')} }` : ``}` +
                 `${subTables.length > 0 ? magenta(` (sub: ${subTables.join(', ')})`) : ``}`;
     }
-    else {
-        toLog = `${typeQuery.get(first) || '💢'}` + time + ` ${final_s}`;
-    }
-    // Filter out a few things
-    const filterOutTable = ['"auth_user"', '"auth_user_session"'];
-    const OnoOfFiltered = tables.length === 1 && filterOutTable.includes(tables[0]);
+    const toFilterOut = options?.tablesToHide ?? [
+        ['__remult_migrations_version'],
+        ['information_Schema.tables'],
+        ['information_schema.columns'],
+        ['ff_auth.accounts'],
+        ['ff_auth.users'],
+        ['ff_auth.users_sessions'],
+        ['_ff_change_logs'],
+    ];
+    const OnoOfFiltered = toFilterOut.some((item) => item.every((i) => tables.map((c) => c.replaceAll('"', '')).includes(i)));
     if (!OnoOfFiltered) {
         // console.log(`toLogLong`, toLogLong)
         log.info(toLog);

package/esm/api/index.d.ts

@@ -1,4 +1,4 @@
-/// <reference types=".pnpm/@sveltejs+kit@2.5.24_@sveltejs+vite-plugin-svelte@3.1.1_svelte@4.2.18_vite@5.4.1_@types+node@_vtylvkjv5lewhfcl4vq2py4rce/node_modules/@sveltejs/kit" />
+/// <reference types=".pnpm/@sveltejs+kit@2.5.24_@sveltejs+vite-plugin-svelte@3.1.2_svelte@4.2.18_vite@5.4.1_@types+node@_lnml5jetshdinsnlj53joqxhde/node_modules/@sveltejs/kit" />
 import { type Handle, type MaybePromise, type RequestEvent } from '@sveltejs/kit';
 import { type ClassType } from 'remult';
 import type { RemultServerOptions } from 'remult/server';
@@ -17,7 +17,7 @@ export type Module = {
     handlePosRemult?: Handle;
     earlyReturn?: (input: Parameters<Handle>[0]) => MaybePromise<{
         early: false;
-        resolve?: never;
+        resolve?: undefined;
     } | {
         early: true;
         resolve: ReturnType<Handle>;

package/esm/api/index.js

@@ -36,6 +36,15 @@ export const firstly = (o) => {
             initRequest: async (kitEvent, op) => {
                 // usefull for later...
                 remult.context.url = kitEvent.url;
+                remult.context.setHeaders = (headers) => {
+                    kitEvent.setHeaders(headers);
+                };
+                remult.context.setCookie = (name, value, opts) => {
+                    kitEvent.cookies.set(name, value, opts);
+                };
+                remult.context.deleteCookie = (name, opts) => {
+                    kitEvent.cookies.delete(name, opts);
+                };
                 for (let i = 0; i < modulesSorted.length; i++) {
                     const f = modulesSorted[i].initRequest;
                     if (f) {
@@ -48,15 +57,6 @@ export const firstly = (o) => {
                         }
                     }
                 }
-                remult.context.setHeaders = (headers) => {
-                    kitEvent.setHeaders(headers);
-                };
-                remult.context.setCookie = (name, value, opts) => {
-                    kitEvent.cookies.set(name, value, opts);
-                };
-                remult.context.deleteCookie = (name, opts) => {
-                    kitEvent.cookies.delete(name, opts);
-                };
             },
             initApi: async (r) => {
                 if (!building) {

package/esm/auth/Adapter.js

@@ -9,13 +9,7 @@ export class RemultLuciaAdapter {
             if (user) {
                 return [
                     { ...session, attributes: {} },
-                    {
-                        ...user,
-                        attributes: {
-                            ...user,
-                            session: { id: session.id, expiresAt: session.expiresAt },
-                        },
-                    },
+                    { ...user, attributes: oSafe.transformDbUserToClientUser(session, user) },
                 ];
             }
         }

package/esm/auth/AuthController.server.d.ts

@@ -10,8 +10,7 @@ export declare class AuthControllerServer {
      */
     static signInDemo(name: string): Promise<string>;
     /**
-     * This is for login / password authentication SignUp
-     * _(The first param `name` can be "anything")_
+     * This is for login / password authentication invite
      */
     static invite(email: string): Promise<"Mail sent !" | "Demo Mail sent !" | "ok">;
     /**

package/esm/auth/AuthController.server.js

@@ -3,11 +3,12 @@ import { DEV } from 'esm-env';
 import { generateId } from 'lucia';
 import { createDate, TimeSpan } from 'oslo';
 import { remult } from 'remult';
-import { green, yellow } from '@kitql/helpers';
-import { AUTH_OPTIONS, getSafeOptions, logAuth, lucia } from '.';
+import { green, magenta, yellow } from '@kitql/helpers';
+import { AUTH_OPTIONS, getSafeOptions, lucia } from '.';
 import { sendMail } from '../mail';
-import { FFAuthProvider } from './Entities.js';
-import { createSession } from './helper';
+import { logAuth } from './client';
+import { FFAuthProvider } from './client/Entities.js';
+import { createOrExtendSession } from './helper';
 import { mergeRoles } from './RoleHelpers';
 async function getArgon() {
     const { Argon2id } = await import('oslo/password');
@@ -58,39 +59,55 @@ export class AuthControllerServer {
             throw new Error(`${name} not found as demo account!`);
         }
         const oSafe = getSafeOptions();
-        let user = await remult.repo(oSafe.User).findFirst({ name });
+        let user = await remult.repo(oSafe.User).findFirst({ identifier: name });
         if (!user) {
             user = remult.repo(oSafe.User).create();
         }
-        user.name = name;
+        user.identifier = name;
         const r = mergeRoles(user.roles, account.roles);
         user.roles = r.roles;
         await remult.repo(oSafe.User).save(user);
-        await createSession(user.id);
+        await createOrExtendSession(user.id);
         return "You're in with demo account!";
     }
     /**
-     * This is for login / password authentication SignUp
-     * _(The first param `name` can be "anything")_
+     * This is for login / password authentication invite
      */
     static async invite(email) {
         const oSafe = getSafeOptions();
-        const existingUser = await remult.repo(oSafe.User).findOne({ where: { name: email } });
-        if (existingUser) {
+        const existingAccount = await remult.repo(oSafe.Account).findOne({
+            where: {
+                providerUserId: email,
+                provider: FFAuthProvider.PASSWORD.id,
+            },
+        });
+        if (existingAccount) {
             // throw Error("Already invited !")
         }
         else {
-            const user = await remult.repo(oSafe.User).insert({
-                name: email,
+            const token = generateId(40);
+            // TODO: Do we create the user or just the account ?!
+            // TODO 2: Invite is by mail... But the invitee can log with another provider... So what do we do?! maybe not checking the provider... and updating?
+            // const user = await remult.repo(oSafe.User).insert({
+            //   identifier: email,
+            // })
+            await remult.repo(oSafe.Account).insert({
+                provider: FFAuthProvider.PASSWORD.id,
+                providerUserId: email,
+                // userId: user.id,
+                // hashPassword: await passwordHash(password),
+                token: token,
+                expiresAt: createDate(new TimeSpan(AUTH_OPTIONS.providers?.password?.verifyMailExpiresIn ?? 5 * 60, 's')),
+                lastVerifiedAt: undefined,
             });
-            const url = `${remult.context.url.origin}`;
+            const url = `${remult.context.url.origin}${oSafe.firstlyData.props.ui?.paths.reset_password}?token=${token}`;
             if (AUTH_OPTIONS?.invitationSend) {
                 await AUTH_OPTIONS?.invitationSend({ email, url });
-                logAuth.success(`Done with custom ${green('invitationSend')} (${yellow(url)})`);
+                logAuth.success(`${green('[custom]')}${magenta('[invitationSend]')} (${yellow(url)})`);
                 return 'Mail sent !';
             }
             else {
-                await sendMail('invite', {
+                await sendMail('invitationSend', {
                     to: email,
                     subject: 'Invitation',
                     templateProps: {
@@ -111,7 +128,7 @@ export class AuthControllerServer {
                         ],
                     },
                 });
-                logAuth.success(`Done with ${green('sendMail')} (${url})`);
+                logAuth.success(`${magenta('[invitationSend]')} (${yellow(url)})`);
                 return 'Demo Mail sent !';
             }
         }
@@ -129,37 +146,49 @@ export class AuthControllerServer {
         if (!oSafe.password_enabled) {
             throw Error('Password is not enabled!');
         }
-        const existingUser = await remult.repo(oSafe.User).findOne({ where: { name: email } });
-        if (existingUser) {
+        const existingAccount = await remult.repo(oSafe.Account).findOne({
+            where: {
+                providerUserId: email,
+                provider: FFAuthProvider.PASSWORD.id,
+            },
+        });
+        if (existingAccount) {
             throw Error("You can't signup twice !");
         }
         checkPassword(password);
-        const user = await remult.repo(oSafe.User).insert({
-            name: email,
-        });
         const token = generateId(40);
-        await remult.repo(oSafe.Account).insert({
-            provider: FFAuthProvider.PASSWORD.id,
-            providerUserId: email,
-            userId: user.id,
-            hashPassword: await passwordHash(password),
-            token: oSafe.verifiedMethod === 'auto' ? undefined : token,
-            expiresAt: oSafe.verifiedMethod === 'auto'
-                ? undefined
-                : createDate(new TimeSpan(AUTH_OPTIONS.providers?.password?.verifyMailExpiresIn ?? 5 * 60, 's')),
-            lastVerifiedAt: oSafe.verifiedMethod === 'auto' ? new Date() : undefined,
+        await remult.dataProvider.transaction(async () => {
+            const user = await remult.repo(oSafe.User).insert({
+                identifier: email,
+            });
+            await remult.repo(oSafe.Account).insert({
+                provider: FFAuthProvider.PASSWORD.id,
+                providerUserId: email,
+                userId: user.id,
+                hashPassword: await passwordHash(password),
+                token: oSafe.verifiedMethod === 'auto' ? undefined : token,
+                expiresAt: oSafe.verifiedMethod === 'auto'
+                    ? undefined
+                    : createDate(new TimeSpan(AUTH_OPTIONS.providers?.password?.verifyMailExpiresIn ?? 5 * 60, 's')),
+                lastVerifiedAt: oSafe.verifiedMethod === 'auto' ? new Date() : undefined,
+            });
         });
         if (oSafe.verifiedMethod === 'auto') {
-            await createSession(user.id);
+            const user = await remult.repo(oSafe.User).findFirst({
+                identifier: email,
+            });
+            if (user) {
+                await createOrExtendSession(user.id);
+            }
         }
         else {
             const url = `${remult.context.url.origin}${oSafe.firstlyData.props.ui?.paths.verify_email}?token=${token}`;
             if (AUTH_OPTIONS.providers?.password?.verifyMailSend) {
                 await AUTH_OPTIONS.providers?.password.verifyMailSend({ email, url });
-                logAuth.success(`Done with custom ${green('verifyMailSend')} (${yellow(url)})`);
+                logAuth.success(`${green('[custom]')}${magenta('[verifyMailSend]')} (${yellow(url)})`);
             }
             else {
-                await sendMail('signUpPassword', {
+                await sendMail('verifyMailSend', {
                     to: email,
                     subject: 'Wecome',
                     templateProps: {
@@ -176,7 +205,7 @@ export class AuthControllerServer {
                         ],
                     },
                 });
-                logAuth.success(`Done with ${green('sendMail')} (${url})`);
+                logAuth.success(`${magenta('[verifyMailSend]')} (${yellow(url)})`);
             }
         }
         return 'ok';
@@ -190,14 +219,16 @@ export class AuthControllerServer {
         if (!oSafe.password_enabled) {
             throw Error('Password is not enabled!');
         }
-        const existingUser = await remult
-            .repo(oSafe.User)
-            .findOne({ where: { name: email }, include: { accounts: true } });
-        const accountPassword = existingUser?.accounts.find((c) => c.provider === FFAuthProvider.PASSWORD.id);
-        if (accountPassword && existingUser) {
-            const validPassword = await passwordVerify(accountPassword?.hashPassword ?? '', password ?? '');
+        const existingAccount = await remult.repo(oSafe.Account).findOne({
+            where: {
+                providerUserId: email,
+                provider: FFAuthProvider.PASSWORD.id,
+            },
+        });
+        if (existingAccount) {
+            const validPassword = await passwordVerify(existingAccount?.hashPassword ?? '', password ?? '');
             if (validPassword) {
-                await createSession(existingUser.id);
+                await createOrExtendSession(existingAccount.userId);
                 return 'ok';
             }
             throw Error('Incorrect username or password');
@@ -212,29 +243,25 @@ export class AuthControllerServer {
         if (!oSafe.password_enabled) {
             throw Error('Password is not enabled!');
         }
-        const u = await remult.repo(getSafeOptions().User).findFirst({ name: email });
-        if (u) {
-            let authAccount = await remult.repo(oSafe.Account).findFirst({
-                userId: u.id,
-            });
-            if (!authAccount) {
-                authAccount = remult.repo(oSafe.Account).create();
-                authAccount.userId = u.id;
-                authAccount.provider = FFAuthProvider.PASSWORD.id;
-                authAccount.providerUserId = email;
-            }
+        const existingAccount = await remult.repo(oSafe.Account).findOne({
+            where: {
+                providerUserId: email,
+                provider: FFAuthProvider.PASSWORD.id,
+            },
+        });
+        if (existingAccount) {
             const token = generateId(40);
-            authAccount.token = token;
-            authAccount.expiresAt = createDate(new TimeSpan(AUTH_OPTIONS.providers?.password?.resetPasswordExpiresIn ?? 5 * 60, 's'));
-            await remult.repo(oSafe.Account).save(authAccount);
+            existingAccount.token = token;
+            existingAccount.expiresAt = createDate(new TimeSpan(AUTH_OPTIONS.providers?.password?.resetPasswordExpiresIn ?? 5 * 60, 's'));
+            await remult.repo(oSafe.Account).save(existingAccount);
             const url = `${remult.context.url.origin}${oSafe.firstlyData.props.ui?.paths.reset_password}?token=${token}`;
             if (AUTH_OPTIONS.providers?.password?.resetPasswordSend) {
                 await AUTH_OPTIONS.providers?.password.resetPasswordSend({ email, url });
-                logAuth.success(`Done with custom ${green('resetPasswordSend')} (${yellow(url)})`);
+                logAuth.success(`${green('[custom]')}${magenta('[resetPasswordSend]')} (${yellow(url)})`);
                 return 'Mail sent !';
             }
             else {
-                await sendMail('forgotPassword', {
+                await sendMail('resetPasswordSend', {
                     to: email,
                     subject: 'Reset your password',
                     templateProps: {
@@ -255,7 +282,7 @@ export class AuthControllerServer {
                         ],
                     },
                 });
-                logAuth.success(`Done with ${green('sendMail')} (${url})`);
+                logAuth.success(`${magenta('[resetPasswordSend]')} (${yellow(url)})`);
                 return 'Demo Mail sent !';
             }
         }
@@ -279,6 +306,10 @@ export class AuthControllerServer {
             throw new Error('token expired');
         }
         checkPassword(password);
+        if (account.userId === undefined) {
+            const user = await remult.repo(oSafe.User).insert({ identifier: account.providerUserId });
+            account.userId = user.id;
+        }
         await lucia.invalidateUserSessions(account.userId);
         // update elements
         account.hashPassword = await passwordHash(password);
@@ -286,7 +317,7 @@ export class AuthControllerServer {
         account.expiresAt = undefined;
         account.lastVerifiedAt = new Date();
         await remult.repo(oSafe.Account).save(account);
-        await createSession(account.userId);
+        await createOrExtendSession(account.userId);
         return 'reseted';
     }
     /** OTP */
@@ -308,11 +339,11 @@ export class AuthControllerServer {
             const issuer = AUTH_OPTIONS.providers.otp.issuer ?? 'firstly';
             const uri = createTOTPKeyURI(issuer, email, secret);
             const oSafe = getSafeOptions();
-            let user = await remult.repo(oSafe.User).findFirst({ name: email });
+            let user = await remult.repo(oSafe.User).findFirst({ identifier: email });
             if (!user) {
                 user = remult.repo(oSafe.User).create();
             }
-            user.name = email;
+            user.identifier = email;
             user = await remult.repo(oSafe.User).save(user);
             let account = await remult
                 .repo(oSafe.Account)
@@ -347,7 +378,7 @@ export class AuthControllerServer {
         }
         const account = accounts[0];
         const user = await remult.repo(oSafe.User).findId(account.userId);
-        if (user?.name !== email) {
+        if (user?.identifier !== email) {
             throw new Error('Invalid otp.');
         }
         const { decodeHex } = await import('oslo/encoding');
@@ -363,7 +394,7 @@ export class AuthControllerServer {
         account.token = undefined;
         account.expiresAt = undefined;
         await remult.repo(oSafe.Account).save(account);
-        await createSession(account.userId);
+        await createOrExtendSession(account.userId);
         return 'verified';
     }
     /** OAUTH */

package/esm/auth/RoleHelpers.d.ts

@@ -1,6 +1,6 @@
 import type { ClassType } from 'remult';
 import { Log } from '@kitql/helpers';
-import { FFAuthUser } from './Entities';
+import { FFAuthUser } from './client/Entities';
 /**
  * will merge the roles and remove duplicates
  * will return a new array & a status if the array was changed

package/esm/auth/RoleHelpers.js

@@ -1,6 +1,6 @@
 import { repo } from 'remult';
 import { cyan, green, Log, yellow } from '@kitql/helpers';
-import { FFAuthUser } from './Entities';
+import { FFAuthUser } from './client/Entities';
 /**
  * will merge the roles and remove duplicates
  * will return a new array & a status if the array was changed
@@ -17,13 +17,13 @@ export const mergeRoles = (existing, newOnes) => {
     return { roles: Array.from(result), changed };
 };
 export const initRoleFromEnv = async (log, userEntity, envValue, role) => {
-    const names = envValue === undefined ? [] : (envValue ?? '').split(',').map((c) => c.trim());
-    for (let i = 0; i < names.length; i++) {
-        const name = names[i].trim();
-        if (name !== '') {
-            let user = await repo(userEntity).findFirst({ name });
+    const identifiers = envValue === undefined ? [] : (envValue ?? '').split(',').map((c) => c.trim());
+    for (let i = 0; i < identifiers.length; i++) {
+        const identifier = identifiers[i].trim();
+        if (identifier !== '') {
+            let user = await repo(userEntity).findFirst({ identifier });
             if (!user) {
-                user = repo(userEntity).create({ name, roles: [role] });
+                user = repo(userEntity).create({ identifier, roles: [role] });
                 await repo(userEntity).save(user);
             }
             else {
@@ -34,8 +34,8 @@ export const initRoleFromEnv = async (log, userEntity, envValue, role) => {
             }
         }
     }
-    if (names.length > 0) {
-        log.info(`${cyan(role)}: ${names.map((c) => green(c.trim())).join(', ')} added via ${yellow(`.env`)}.`);
+    if (identifiers.length > 0) {
+        log.info(`${cyan(role)}: ${identifiers.map((c) => green(c.trim())).join(', ')} added via ${yellow(`.env`)}.`);
     }
     else {
         log.info(`${cyan(role)}: No users added via ${yellow(`.env`)}.`);

package/esm/auth/client/Auth.d.ts

@@ -1,14 +1,24 @@
 import type { AuthorizationURLOptions } from '..';
 export declare class Auth {
+    /** DO NOT USE */
     static signOutFn: any;
+    /** DO NOT USE */
     static signInDemoFn: any;
+    /** DO NOT USE */
     static inviteFn: any;
+    /** DO NOT USE */
     static signUpPasswordFn: any;
+    /** DO NOT USE */
     static signInPasswordFn: any;
+    /** DO NOT USE */
     static forgotPasswordFn: any;
+    /** DO NOT USE */
     static resetPasswordFn: any;
+    /** DO NOT USE */
     static signInOTPFn: any;
+    /** DO NOT USE */
     static verifyOtpFn: any;
+    /** DO NOT USE */
     static signInOAuthGetUrlFn: any;
     /**
      * Sign out the current user
@@ -20,18 +30,15 @@ export declare class Auth {
      */
     static signInDemo(name: string): Promise<any>;
     /**
-     * This is for login / password authentication SignUp
-     * _(The first param `name` can be "anything")_
+     * This is for login / password authentication Invite someone
      */
     static invite(email: string): Promise<any>;
     /**
      * This is for login / password authentication SignUp
-     * _(The first param `email` can be "anything")_
      */
     static signUpPassword(email: string, password: string): Promise<any>;
     /**
      * This is for login / password authentication SignIn
-     * _(The first param `email` can be "anything")_
      */
     static signInPassword(email: string, password: string): Promise<any>;
     /**