firstly 0.0.3 → 0.0.5

package/esm/auth/Entities.js

@@ -4,17 +4,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var AuthProvider_1;
+var FFAuthProvider_1;
 import { Entity, Fields, Relations, Validators, ValueListFieldType } from 'remult';
-import { KitBaseEnum, KitRole } from '../';
-export const KitAuthRole = {
-    Admin: 'KitAuthAdmin',
+import { BaseEnum, FF_Role } from '../';
+export const FF_Auth_Role = {
+    Admin: 'FF_Auth_Role.Admin',
 };
-let KitAuthUser = class KitAuthUser {
+let FFAuthUser = class FFAuthUser {
     id;
     createdAt;
     updatedAt;
-    // @Fields.string<KitAuthUser>({
     name;
     roles = [];
     accounts;
@@ -22,13 +21,13 @@ let KitAuthUser = class KitAuthUser {
 };
 __decorate([
     Fields.cuid()
-], KitAuthUser.prototype, "id", void 0);
+], FFAuthUser.prototype, "id", void 0);
 __decorate([
     Fields.createdAt()
-], KitAuthUser.prototype, "createdAt", void 0);
+], FFAuthUser.prototype, "createdAt", void 0);
 __decorate([
     Fields.updatedAt()
-], KitAuthUser.prototype, "updatedAt", void 0);
+], FFAuthUser.prototype, "updatedAt", void 0);
 __decorate([
     Fields.string({
         validate: [
@@ -39,7 +38,7 @@ __decorate([
             },
         ],
     })
-], KitAuthUser.prototype, "name", void 0);
+], FFAuthUser.prototype, "name", void 0);
 __decorate([
     Fields.object({
         valueConverter: {
@@ -47,71 +46,75 @@ __decorate([
             fromDb: (x) => (x ? x.split(',') : undefined),
         },
     })
-], KitAuthUser.prototype, "roles", void 0);
+], FFAuthUser.prototype, "roles", void 0);
 __decorate([
-    Relations.toMany(() => KitAuthAccount, 'userId')
-], KitAuthUser.prototype, "accounts", void 0);
+    Relations.toMany(() => FFAuthAccount, 'userId')
+], FFAuthUser.prototype, "accounts", void 0);
 __decorate([
-    Relations.toMany(() => KitAuthUserSession, 'userId')
-], KitAuthUser.prototype, "sessions", void 0);
-KitAuthUser = __decorate([
-    Entity('kit_auth_user', {
-        allowApiCrud: [KitAuthRole.Admin, KitRole.Admin],
-        dbName: 'auth.kit_auth_user',
+    Relations.toMany(() => FFAuthUserSession, 'userId')
+], FFAuthUser.prototype, "sessions", void 0);
+FFAuthUser = __decorate([
+    Entity('ff_auth.users', {
+        allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
+        caption: 'Auth - Users',
     })
-], KitAuthUser);
-export { KitAuthUser };
-let KitAuthAccount = class KitAuthAccount {
+], FFAuthUser);
+export { FFAuthUser };
+let FFAuthAccount = class FFAuthAccount {
+    id;
     createdAt;
     updatedAt;
     userId;
     user;
-    provider = AuthProvider.PASSWORD.id;
+    provider = FFAuthProvider.PASSWORD.id;
     providerUserId = '';
     hashPassword;
     token;
     expiresAt;
     lastVerifiedAt;
 };
+__decorate([
+    Fields.cuid()
+], FFAuthAccount.prototype, "id", void 0);
 __decorate([
     Fields.createdAt()
-], KitAuthAccount.prototype, "createdAt", void 0);
+], FFAuthAccount.prototype, "createdAt", void 0);
 __decorate([
     Fields.updatedAt()
-], KitAuthAccount.prototype, "updatedAt", void 0);
+], FFAuthAccount.prototype, "updatedAt", void 0);
 __decorate([
     Fields.string()
-], KitAuthAccount.prototype, "userId", void 0);
+], FFAuthAccount.prototype, "userId", void 0);
 __decorate([
-    Relations.toOne(() => KitAuthUser, 'userId')
-], KitAuthAccount.prototype, "user", void 0);
+    Relations.toOne(() => FFAuthUser, 'userId')
+], FFAuthAccount.prototype, "user", void 0);
 __decorate([
     Fields.string()
-], KitAuthAccount.prototype, "provider", void 0);
+], FFAuthAccount.prototype, "provider", void 0);
 __decorate([
     Fields.string()
-], KitAuthAccount.prototype, "providerUserId", void 0);
+], FFAuthAccount.prototype, "providerUserId", void 0);
 __decorate([
     Fields.string({ includeInApi: false, allowNull: true })
-], KitAuthAccount.prototype, "hashPassword", void 0);
+], FFAuthAccount.prototype, "hashPassword", void 0);
 __decorate([
     Fields.string({ includeInApi: false, allowNull: true })
-], KitAuthAccount.prototype, "token", void 0);
+], FFAuthAccount.prototype, "token", void 0);
 __decorate([
     Fields.date({ includeInApi: false, allowNull: true })
-], KitAuthAccount.prototype, "expiresAt", void 0);
+], FFAuthAccount.prototype, "expiresAt", void 0);
 __decorate([
     Fields.date({ includeInApi: false, allowNull: true })
-], KitAuthAccount.prototype, "lastVerifiedAt", void 0);
-KitAuthAccount = __decorate([
-    Entity('kit_auth_account', {
-        allowApiCrud: [KitAuthRole.Admin, KitRole.Admin],
-        dbName: 'auth.kit_auth_account',
-        id: { provider: true, userId: true },
+], FFAuthAccount.prototype, "lastVerifiedAt", void 0);
+FFAuthAccount = __decorate([
+    Entity('ff_auth.accounts', {
+        allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
+        caption: 'Auth - Accounts',
+        // id: { provider: true, userId: true },
     })
-], KitAuthAccount);
-export { KitAuthAccount };
-let KitAuthUserSession = class KitAuthUserSession {
+], FFAuthAccount);
+export { FFAuthAccount };
+let FFAuthUserSession = class FFAuthUserSession {
     id;
     expiresAt;
     userId;
@@ -119,36 +122,36 @@ let KitAuthUserSession = class KitAuthUserSession {
 };
 __decorate([
     Fields.cuid()
-], KitAuthUserSession.prototype, "id", void 0);
+], FFAuthUserSession.prototype, "id", void 0);
 __decorate([
     Fields.date()
-], KitAuthUserSession.prototype, "expiresAt", void 0);
+], FFAuthUserSession.prototype, "expiresAt", void 0);
 __decorate([
     Fields.string()
-], KitAuthUserSession.prototype, "userId", void 0);
-__decorate([
-    Relations.toOne(() => KitAuthUser, 'userId')
-], KitAuthUserSession.prototype, "user", void 0);
-KitAuthUserSession = __decorate([
-    Entity('kit_auth_session', {
-        allowApiCrud: [KitAuthRole.Admin, KitRole.Admin],
-        dbName: 'auth.kit_auth_session',
+], FFAuthUserSession.prototype, "userId", void 0);
+__decorate([
+    Relations.toOne(() => FFAuthUser, 'userId')
+], FFAuthUserSession.prototype, "user", void 0);
+FFAuthUserSession = __decorate([
+    Entity('ff_auth.users_sessions', {
+        allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
+        caption: 'Auth - Users sessions',
     })
-], KitAuthUserSession);
-export { KitAuthUserSession };
-let AuthProvider = class AuthProvider extends KitBaseEnum {
-    static { AuthProvider_1 = this; }
-    static DEMO = new AuthProvider_1('DEMO', { caption: 'Demo' });
-    static PASSWORD = new AuthProvider_1('PASSWORD', { caption: 'Password' });
-    static OTP = new AuthProvider_1('OTP', { caption: 'TOTP' });
-    static OAUTH = new AuthProvider_1('OAUTH', { caption: 'OAUTH' });
+], FFAuthUserSession);
+export { FFAuthUserSession };
+let FFAuthProvider = class FFAuthProvider extends BaseEnum {
+    static { FFAuthProvider_1 = this; }
+    static DEMO = new FFAuthProvider_1('DEMO', { caption: 'Demo' });
+    static PASSWORD = new FFAuthProvider_1('PASSWORD', { caption: 'Password' });
+    static OTP = new FFAuthProvider_1('OTP', { caption: 'TOTP' });
+    static OAUTH = new FFAuthProvider_1('OAUTH', { caption: 'OAUTH' });
     constructor(id, o) {
         super(id, {
             ...o,
         });
     }
 };
-AuthProvider = AuthProvider_1 = __decorate([
+FFAuthProvider = FFAuthProvider_1 = __decorate([
     ValueListFieldType()
-], AuthProvider);
-export { AuthProvider };
+], FFAuthProvider);
+export { FFAuthProvider };

package/esm/auth/README.md

@@ -0,0 +1,13 @@
+# Firstly - Module - Auth
+
+➡️ Doc available [here](https://firstly.fun/modules/auth).
+
+## Complement
+
+### Lucia adapter
+
+Under the hood, we created a lucia adapter, you can check the code [here](./Adapter.ts) . Feel free
+to copy/paste it in your own codebase. You can also suggest improvements here 😉.
+
+By default, all tables/fields will show up in your admin and you are able to extend then with your
+own fields.

package/esm/auth/{RoleController.d.ts → RoleHelpers.d.ts}

@@ -1,6 +1,6 @@
 import type { ClassType } from 'remult';
 import { Log } from '@kitql/helpers';
-import { KitAuthUser } from './Entities';
+import { FFAuthUser } from './Entities';
 /**
  * will merge the roles and remove duplicates
  * will return a new array & a status if the array was changed
@@ -9,6 +9,4 @@ export declare const mergeRoles: (existing: string[], newOnes: string[] | undefi
     roles: string[];
     changed: boolean;
 };
-export declare class RoleController {
-    static initRoleFromEnv: (log: Log, userEntity: ClassType<KitAuthUser>, envKey: string, role: string) => Promise<void>;
-}
+export declare const initRoleFromEnv: (log: Log, userEntity: ClassType<FFAuthUser>, envValue: string | undefined, role: string) => Promise<void>;

package/esm/auth/RoleHelpers.js

@@ -0,0 +1,43 @@
+import { repo } from 'remult';
+import { cyan, green, Log, yellow } from '@kitql/helpers';
+import { FFAuthUser } from './Entities';
+/**
+ * will merge the roles and remove duplicates
+ * will return a new array & a status if the array was changed
+ */
+export const mergeRoles = (existing, newOnes) => {
+    const result = new Set(existing);
+    let changed = false;
+    for (const role of newOnes ?? []) {
+        if (!result.has(role)) {
+            result.add(role);
+            changed = true;
+        }
+    }
+    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 });
+            if (!user) {
+                user = repo(userEntity).create({ name, roles: [role] });
+                await repo(userEntity).save(user);
+            }
+            else {
+                if (!user.roles.includes(role)) {
+                    user.roles.push(role);
+                    await repo(userEntity).save(user);
+                }
+            }
+        }
+    }
+    if (names.length > 0) {
+        log.info(`${cyan(role)}: ${names.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

@@ -0,0 +1,69 @@
+import type { AuthorizationURLOptions } from '..';
+export declare class Auth {
+    static signOutFn: any;
+    static signInDemoFn: any;
+    static inviteFn: any;
+    static signUpPasswordFn: any;
+    static signInPasswordFn: any;
+    static forgotPasswordFn: any;
+    static resetPasswordFn: any;
+    static signInOTPFn: any;
+    static verifyOtpFn: any;
+    static signInOAuthGetUrlFn: any;
+    /**
+     * Sign out the current user
+     */
+    static signOut(): Promise<any>;
+    /**
+     * Sign in with a demo account
+     * _(The easiest way to demo & test your application)_
+     */
+    static signInDemo(name: string): Promise<any>;
+    /**
+     * This is for login / password authentication SignUp
+     * _(The first param `name` can be "anything")_
+     */
+    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>;
+    /**
+     * Forgot your password ? Send a mail to reset it.
+     */
+    static forgotPassword(email: string): Promise<any>;
+    /**
+     * Reset your password with a token
+     */
+    static resetPassword(token: string, password: string): Promise<any>;
+    /** OTP */
+    static signInOTP(email: string): Promise<any>;
+    /**
+     * Verify the OTP code
+     */
+    static verifyOtp(email: string, otp: string | number): Promise<any>;
+    /** OAUTH */
+    /**
+     * The the url to redirect to for the OAuth provider
+     * @param provider Has to mach one of `AUTH_OPTIONS.providers.oAuths` your configured
+     *
+     * To be used like this for example:
+     * ```
+     * const url = await Auth.signInOAuthGetUrl('github')
+     * window.location.href = url
+     * ```
+     *
+     * _(popup example should work too, and a nice example/componant would be appreciated)_
+     */
+    static signInOAuthGetUrl<T extends keyof AuthorizationURLOptions>(o: {
+        provider: T;
+        options?: AuthorizationURLOptions[T];
+        redirect?: string;
+    }): Promise<any>;
+}

package/esm/auth/client/Auth.js

@@ -0,0 +1,121 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BackendMethod } from 'remult';
+export class Auth {
+    static signOutFn;
+    static signInDemoFn;
+    static inviteFn;
+    static signUpPasswordFn;
+    static signInPasswordFn;
+    static forgotPasswordFn;
+    static resetPasswordFn;
+    static signInOTPFn;
+    static verifyOtpFn;
+    static signInOAuthGetUrlFn;
+    /**
+     * Sign out the current user
+     */
+    static async signOut() {
+        return await Auth.signOutFn();
+    }
+    /**
+     * Sign in with a demo account
+     * _(The easiest way to demo & test your application)_
+     */
+    static async signInDemo(name) {
+        return await Auth.signInDemoFn(name);
+    }
+    /**
+     * This is for login / password authentication SignUp
+     * _(The first param `name` can be "anything")_
+     */
+    static async invite(email) {
+        return await Auth.inviteFn(email);
+    }
+    /**
+     * This is for login / password authentication SignUp
+     * _(The first param `email` can be "anything")_
+     */
+    static async signUpPassword(email, password) {
+        return await Auth.signUpPasswordFn(email, password);
+    }
+    /**
+     * This is for login / password authentication SignIn
+     * _(The first param `email` can be "anything")_
+     */
+    static async signInPassword(email, password) {
+        return await Auth.signInPasswordFn(email, password);
+    }
+    /**
+     * Forgot your password ? Send a mail to reset it.
+     */
+    static async forgotPassword(email) {
+        return await Auth.forgotPasswordFn(email);
+    }
+    /**
+     * Reset your password with a token
+     */
+    static async resetPassword(token, password) {
+        return await Auth.resetPasswordFn(token, password);
+    }
+    /** OTP */
+    static async signInOTP(email) {
+        return await Auth.signInOTPFn(email);
+    }
+    /**
+     * Verify the OTP code
+     */
+    static async verifyOtp(email, otp) {
+        return await Auth.verifyOtpFn(email, otp);
+    }
+    /** OAUTH */
+    /**
+     * The the url to redirect to for the OAuth provider
+     * @param provider Has to mach one of `AUTH_OPTIONS.providers.oAuths` your configured
+     *
+     * To be used like this for example:
+     * ```
+     * const url = await Auth.signInOAuthGetUrl('github')
+     * window.location.href = url
+     * ```
+     *
+     * _(popup example should work too, and a nice example/componant would be appreciated)_
+     */
+    static async signInOAuthGetUrl(o) {
+        return await Auth.signInOAuthGetUrlFn(o);
+    }
+}
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "signOut", null);
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "signInDemo", null);
+__decorate([
+    BackendMethod({ allowed: false })
+], Auth, "invite", null);
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "signUpPassword", null);
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "signInPassword", null);
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "forgotPassword", null);
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "resetPassword", null);
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "signInOTP", null);
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "verifyOtp", null);
+__decorate([
+    BackendMethod({ allowed: true })
+], Auth, "signInOAuthGetUrl", null);

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

@@ -0,0 +1,2 @@
+import { Auth } from './Auth';
+export { Auth };

package/esm/auth/client/index.js

@@ -0,0 +1,2 @@
+import { Auth } from './Auth';
+export { Auth };

package/esm/auth/index.d.ts

@@ -4,33 +4,32 @@ import type { ClassType, UserInfo } from 'remult';
 import { Log } from '@kitql/helpers';
 import type { Module } from '../api';
 import type { ResolvedType } from '../utils/types';
-import { KitAuthAccount, KitAuthUser, KitAuthUserSession } from './Entities';
+import { FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession } from './Entities';
 import type { firstlyData } from './types';
 export type { firstlyData };
-export { KitAuthUser, KitAuthAccount, AuthProvider, KitAuthUserSession } from './Entities';
-export { AuthController } from './AuthController';
+export { FFAuthUser, FFAuthAccount, FFAuthProvider, FFAuthUserSession };
 export type AuthorizationURLOptions = Record<string, {
     scopes?: string[];
 }>;
-export type DynamicAuthorizationURLOptions<T extends KitOAuth2Provider[] = KitOAuth2Provider[]> = T extends Array<infer O> ? O extends KitOAuth2Provider ? {
+export type DynamicAuthorizationURLOptions<T extends FFOAuth2Provider[] = FFOAuth2Provider[]> = T extends Array<infer O> ? O extends FFOAuth2Provider ? {
     [P in O['name']]: ReturnType<O['authorizationURLOptions']>;
 } : never : never;
 export declare const logAuth: Log;
-export { KitAuthRole } from './Entities';
+export { FF_Auth_Role } from './Entities';
 type OAuth2UserInfo = {
     raw?: any;
     providerUserId: string;
     /** Will take the first option available */
     nameOptions: string[];
 };
-export type KitOAuth2Provider<LitName extends string = string, T extends ArcticOAuth2Provider | ArcticOAuth2ProviderWithPKCE = ArcticOAuth2Provider> = {
+export type FFOAuth2Provider<LitName extends string = string, T extends ArcticOAuth2Provider | ArcticOAuth2ProviderWithPKCE = ArcticOAuth2Provider> = {
     name: LitName;
     getArcticProvider: () => T;
     isPKCE: T extends ArcticOAuth2Provider ? false : T extends ArcticOAuth2ProviderWithPKCE ? true : never;
     authorizationURLOptions: () => T extends ArcticOAuth2Provider ? Parameters<T['createAuthorizationURL']>[1] : T extends ArcticOAuth2ProviderWithPKCE ? Parameters<T['createAuthorizationURL']>[2] : never;
     getUserInfo(tokens: ResolvedType<ReturnType<T['validateAuthorizationCode']>>): Promise<OAuth2UserInfo>;
 };
-type AuthOptions<TUserEntity extends KitAuthUser = KitAuthUser, TSessionEntity extends KitAuthUserSession = KitAuthUserSession, TAccountEntity extends KitAuthAccount = KitAuthAccount> = {
+type AuthOptions<TUserEntity extends FFAuthUser = FFAuthUser, TSessionEntity extends FFAuthUserSession = FFAuthUserSession, TAccountEntity extends FFAuthAccount = FFAuthAccount> = {
     customEntities?: {
         User?: ClassType<TUserEntity>;
         Session?: ClassType<TSessionEntity>;
@@ -112,14 +111,14 @@ type AuthOptions<TUserEntity extends KitAuthUser = KitAuthUser, TSessionEntity e
                 uri: string;
             }) => Promise<void>;
         };
-        oAuths?: KitOAuth2Provider[];
+        oAuths?: FFOAuth2Provider[];
     };
 };
 export declare let AUTH_OPTIONS: AuthOptions;
 export declare const getSafeOptions: () => {
-    User: ClassType<KitAuthUser>;
-    Session: ClassType<KitAuthUserSession>;
-    Account: ClassType<KitAuthAccount>;
+    User: ClassType<FFAuthUser>;
+    Session: ClassType<FFAuthUserSession>;
+    Account: ClassType<FFAuthAccount>;
     signUp: boolean;
     password_enabled: boolean;
     otp_enabled: boolean;