firstly 0.0.4 → 0.0.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # firstly
 
+## 0.0.5
+
+### Patch Changes
+
+- [#20](https://github.com/jycouet/firstly/pull/20)
+  [`5b365a4`](https://github.com/jycouet/firstly/commit/5b365a474619f611b0eb0bfe38bbbb262acb3a7e)
+  Thanks [@jycouet](https://github.com/jycouet)! - [BREAKING] Renaming almost all exports! (Some
+  `FF_` and `ff_` only when direct collision with other packages)
+
+- [#20](https://github.com/jycouet/firstly/pull/20)
+  [`b1ea110`](https://github.com/jycouet/firstly/commit/b1ea1101c45c137e477a937a8c6d130b346b2bb9)
+  Thanks [@jycouet](https://github.com/jycouet)! - tweak cli, update github auth
+
 ## 0.0.4
 
 ### Patch Changes

package/esm/{KitBaseEnum.d.ts → BaseEnum.d.ts}

@@ -1,25 +1,36 @@
 import { type IdFilter } from 'remult';
-import type { ClassType, FindOptionsBase } from 'remult';
-export type KitIcon = {
+import type { FindOptionsBase, Repository } from 'remult';
+export type FF_Icon = {
     data?: string | string[];
     size?: string | number;
     class?: string | string[];
     style?: string | string[];
     caption?: string;
 };
-export type KitBaseEnumOptions<Entity = any> = {
+export type BaseItem = BaseEnumOptions & {
+    id: string;
+    captionSub?: string | (string | undefined)[];
+    href?: string;
+    repo?: Repository<any>;
+    sub?: {
+        captionPre?: string;
+        repo?: Repository<any>;
+        item?: any;
+    };
+};
+export type BaseEnumOptions<Entity = any> = {
     caption?: string;
-    icon?: KitIcon;
+    icon?: FF_Icon;
     where?: IdFilter<Entity> | FindOptionsBase<Entity>['where'];
     class?: string;
 };
-export declare class KitBaseEnum<Entity = any> {
+export declare class BaseEnum<Entity = any> {
     id: string;
     caption?: string;
-    icon?: KitIcon;
+    icon?: FF_Icon;
     where?: IdFilter<Entity> | FindOptionsBase<Entity>['where'];
     class?: string;
-    constructor(_id: string | number, options?: KitBaseEnumOptions<Entity>);
+    constructor(_id: string | number, options?: BaseEnumOptions<Entity>);
     getWhere: () => this | Entity[] | {
         $ne?: Entity | Entity[] | undefined;
         '!='?: Entity | Entity[] | undefined;
@@ -31,5 +42,3 @@ export declare class KitBaseEnum<Entity = any> {
         } ? number : string>;
     } | import("remult").EntityFilter<Entity> | NonNullable<Entity>;
 }
-export declare const getEnum: <T extends KitBaseEnum<any>>(baseEnum: ClassType<T>, id: string | undefined | null) => T | undefined;
-export declare const getEnums: <T extends KitBaseEnum<any>>(baseEnum: ClassType<T>) => T[];

package/esm/{KitBaseEnum.js → BaseEnum.js}

@@ -1,5 +1,5 @@
-import { getValueList } from 'remult';
-export class KitBaseEnum {
+import {} from 'remult';
+export class BaseEnum {
     id;
     caption;
     icon;
@@ -19,14 +19,3 @@ export class KitBaseEnum {
         return this.where ? this.where : this;
     };
 }
-export const getEnum = (baseEnum, id) => {
-    if (!id) {
-        return undefined;
-    }
-    // @ts-ignore
-    const found = getValueList(baseEnum).find((c) => c.id === id);
-    return found;
-};
-export const getEnums = (baseEnum) => {
-    return getValueList(baseEnum) || [];
-};

package/esm/{KitEntity.d.ts → FF_Entity.d.ts}

@@ -1,2 +1,2 @@
 import { type EntityOptions } from 'remult';
-export declare function KitEntity<entityType>(key: string, options: EntityOptions<entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType>): (target: any, info?: import("remult/src/remult3/remult3").ClassDecoratorContextStub<entityType extends infer T ? T extends entityType ? T extends new (...args: any) => any ? T : never : never : never> | undefined) => any;
+export declare function FF_Entity<entityType>(key: string, options: EntityOptions<entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType>): (target: any, info?: import("remult/src/remult3/remult3").ClassDecoratorContextStub<entityType extends infer T ? T extends entityType ? T extends new (...args: any) => any ? T : never : never : never> | undefined) => any;

package/esm/{KitEntity.js → FF_Entity.js}

@@ -1,14 +1,14 @@
 import { Entity } from 'remult';
-export function KitEntity(key, options) {
-    const toAllow = (permission) => {
-        if (permission) {
-            if (Array.isArray(permission)) {
-                return permission.map((p) => p.id);
-            }
-            return permission.id;
+const toAllow = (permission) => {
+    if (permission) {
+        if (Array.isArray(permission)) {
+            return permission.map((p) => p.id);
         }
-        return undefined;
-    };
+        return permission.id;
+    }
+    return undefined;
+};
+export function FF_Entity(key, options) {
     return Entity(key, {
         ...options,
         allowApiCrud: options.allowApiCrud ?? toAllow(options.permissionApiCrud),

package/esm/{KitFields.d.ts → FF_Fields.d.ts}

@@ -1,6 +1,5 @@
-import { type FieldOptions, type FieldValidator, type StringFieldOptions } from 'remult';
-export declare function addValidator(validators: FieldOptions['validate'], newValidator: FieldOptions['validate'], atStart?: boolean): FieldValidator<unknown, unknown> | FieldValidator<unknown, unknown>[] | undefined;
-export declare class KitFields {
+import { type FieldOptions, type StringFieldOptions } from 'remult';
+export declare class FF_Fields {
     static string<entityType = unknown, valueType = string>(o?: StringFieldOptions<entityType, valueType>): import("remult").ClassFieldDecorator<entityType, valueType | undefined>;
     static currency<entityType = unknown>(o?: FieldOptions<entityType, number>): import("remult").ClassFieldDecorator<entityType, number | undefined>;
     static dateOnly<entityType = any>(o?: FieldOptions<entityType, Date>): import("remult").ClassFieldDecorator<entityType, Date | undefined>;

package/esm/{KitFields.js → FF_Fields.js}

@@ -1,18 +1,21 @@
 import { Fields, Validators, } from 'remult';
 import { displayCurrency } from './formats';
-import { getEnums } from './KitBaseEnum';
+import { getEnums } from './helper';
 // Translate default messages
 // REMULT P3 JYC: I need to set this here the one of my app are not overwriting these...
 // It look like I have 2 remult loaded... But even trying to remove one, I still have the issue
 Validators.unique.defaultMessage = 'Existe déjà!';
 Validators.required.defaultMessage = 'Obligatoire!';
-export function addValidator(validators, newValidator, atStart = false) {
-    if (!newValidator)
-        return validators;
-    const newValidators = Array.isArray(newValidator) ? newValidator : [newValidator];
-    const validatorsArray = Array.isArray(validators) ? validators : validators ? [validators] : [];
-    return atStart ? [...newValidators, ...validatorsArray] : [...validatorsArray, ...newValidators];
-}
+// export function addValidators(
+//   validators: FieldOptions['validate'],
+//   newValidator: FieldOptions['validate'],
+//   atStart = false,
+// ) {
+//   if (!newValidator) return validators
+//   const newValidators = Array.isArray(newValidator) ? newValidator : [newValidator]
+//   const validatorsArray = Array.isArray(validators) ? validators : validators ? [validators] : []
+//   return atStart ? [...newValidators, ...validatorsArray] : [...validatorsArray, ...newValidators]
+// }
 // REMULT P2: A/ Add in the doc that allowNull is false by default
 //            B/ Would be great to have a Validators.required automatically when allowNull is not true.
 //            C/ WARNING Validators.required is also checking for empty string
@@ -24,6 +27,7 @@ const validate_update_when_not_allow_null = (o) => {
         (o.allowNull === undefined || o.allowNull === false) &&
         // if require: false is explicitly set, then we don't need to add required validator
         o.required !== false) {
+        // addValidators(o.validate, [Validators.required], true)
         validate.push(Validators.required);
     }
     // let's add original validate if any
@@ -37,7 +41,7 @@ const validate_update_when_not_allow_null = (o) => {
     }
     return validate;
 };
-export class KitFields {
+export class FF_Fields {
     static string(o) {
         if (o === undefined) {
             o = {};

package/esm/ROUTES.js

@@ -27,7 +27,7 @@ const ACTIONS = {};
  * LINKS
  */
 const LINKS = {
-    "firstly_sign_in": `/fly/auth/sign-in`,
+    "firstly_sign_in": `/ff/auth/sign-in`,
     "remult_admin": `/api/admin`,
     "github": (params) => {
         params = params ?? {};

package/esm/SqlDatabase/FF_LogToConsole.d.ts

@@ -0,0 +1 @@
+export declare const FF_LogToConsole: (duration: number, query: string, args: Record<string, any>, short?: boolean) => string | undefined;

package/esm/SqlDatabase/{LogToConsoleCustom.js → 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 LogToConsoleCustom = (duration, query, args, short = true) => {
+export const FF_LogToConsole = (duration, query, args, short = true) => {
     const rawSql = query
         .replace(/(\r\n|\n|\r|\t)/gm, ' ')
         .replace(/  +/g, ' ')

package/esm/api/index.d.ts

@@ -1,3 +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" />
 import { type Handle, type MaybePromise, type RequestEvent } from '@sveltejs/kit';
 import { type ClassType } from 'remult';
 import type { RemultServerOptions } from 'remult/server';

package/esm/auth/AuthController.server.js

@@ -6,7 +6,7 @@ import { remult } from 'remult';
 import { green, yellow } from '@kitql/helpers';
 import { AUTH_OPTIONS, getSafeOptions, logAuth, lucia } from '.';
 import { sendMail } from '../mail';
-import { AuthProvider } from './Entities.js';
+import { FFAuthProvider } from './Entities.js';
 import { createSession } from './helper';
 import { mergeRoles } from './RoleHelpers';
 async function getArgon() {
@@ -124,7 +124,7 @@ export class AuthControllerServer {
         });
         const token = generateId(40);
         await remult.repo(oSafe.Account).insert({
-            provider: AuthProvider.PASSWORD.id,
+            provider: FFAuthProvider.PASSWORD.id,
             providerUserId: email,
             userId: user.id,
             hashPassword: await passwordHash(password),
@@ -167,7 +167,7 @@ export class AuthControllerServer {
         const existingUser = await remult
             .repo(oSafe.User)
             .findOne({ where: { name: email }, include: { accounts: true } });
-        const accountPassword = existingUser?.accounts.find((c) => c.provider === AuthProvider.PASSWORD.id);
+        const accountPassword = existingUser?.accounts.find((c) => c.provider === FFAuthProvider.PASSWORD.id);
         if (accountPassword && existingUser) {
             const validPassword = await passwordVerify(accountPassword?.hashPassword ?? '', password ?? '');
             if (validPassword) {
@@ -194,7 +194,7 @@ export class AuthControllerServer {
             if (!authAccount) {
                 authAccount = remult.repo(oSafe.Account).create();
                 authAccount.userId = u.id;
-                authAccount.provider = AuthProvider.PASSWORD.id;
+                authAccount.provider = FFAuthProvider.PASSWORD.id;
                 authAccount.providerUserId = email;
             }
             const token = generateId(40);
@@ -230,7 +230,7 @@ export class AuthControllerServer {
         }
         const account = await remult
             .repo(oSafe.Account)
-            .findFirst({ token, provider: AuthProvider.PASSWORD.id });
+            .findFirst({ token, provider: FFAuthProvider.PASSWORD.id });
         if (!account) {
             throw new Error('Invalid token');
         }
@@ -275,12 +275,12 @@ export class AuthControllerServer {
             user = await remult.repo(oSafe.User).save(user);
             let account = await remult
                 .repo(oSafe.Account)
-                .findFirst({ userId: user.id, provider: AuthProvider.OTP.id });
+                .findFirst({ userId: user.id, provider: FFAuthProvider.OTP.id });
             if (!account) {
                 account = remult.repo(oSafe.Account).create();
             }
             account.userId = user.id;
-            account.provider = AuthProvider.OTP.id;
+            account.provider = FFAuthProvider.OTP.id;
             account.token = otp;
             account.hashPassword = secretEncoded;
             await remult.repo(oSafe.Account).save(account);
@@ -299,7 +299,7 @@ export class AuthControllerServer {
     static async verifyOtp(email, otp) {
         const oSafe = getSafeOptions();
         const accounts = await remult.repo(oSafe.Account).find({
-            where: { token: String(otp), provider: AuthProvider.OTP.id },
+            where: { token: String(otp), provider: FFAuthProvider.OTP.id },
         });
         if (accounts.length === 0) {
             throw new Error('Invalid otp');
@@ -393,6 +393,6 @@ export class AuthControllerServer {
                 throw new Error(`${o.provider} not well configured!`);
             }
         }
-        throw new Error(`${o.provider} is not configured!`);
+        throw new Error(`${o.provider} is not configured! (Module: auth, section: providers.oAuths: [${o.provider}] missing)`);
     }
 }

package/esm/auth/Entities.d.ts

@@ -1,22 +1,23 @@
-import { KitBaseEnum } from '../';
-import type { KitBaseEnumOptions } from '../';
-export declare const KitAuthRole: {
-    readonly Admin: "KitAuthAdmin";
+import { BaseEnum } from '../';
+import type { BaseEnumOptions } from '../';
+export declare const FF_Auth_Role: {
+    readonly Admin: "FF_Auth_Role.Admin";
 };
-export declare class KitAuthUser {
+export declare class FFAuthUser {
     id: string;
     createdAt: Date;
     updatedAt?: Date;
     name: string;
     roles: string[];
-    accounts: KitAuthAccount[];
-    sessions: KitAuthUserSession[];
+    accounts: FFAuthAccount[];
+    sessions: FFAuthUserSession[];
 }
-export declare class KitAuthAccount {
+export declare class FFAuthAccount {
+    id: string;
     createdAt: Date;
     updatedAt?: Date;
     userId: string;
-    user: KitAuthUser;
+    user: FFAuthUser;
     provider: string;
     providerUserId: string;
     hashPassword?: string;
@@ -24,16 +25,16 @@ export declare class KitAuthAccount {
     expiresAt?: Date;
     lastVerifiedAt?: Date;
 }
-export declare class KitAuthUserSession {
+export declare class FFAuthUserSession {
     id: string;
     expiresAt: Date;
     userId: string;
-    user: KitAuthUser;
+    user: FFAuthUser;
 }
-export declare class AuthProvider extends KitBaseEnum {
-    static DEMO: AuthProvider;
-    static PASSWORD: AuthProvider;
-    static OTP: AuthProvider;
-    static OAUTH: AuthProvider;
-    constructor(id: string, o?: KitBaseEnumOptions);
+export declare class FFAuthProvider extends BaseEnum {
+    static DEMO: FFAuthProvider;
+    static PASSWORD: FFAuthProvider;
+    static OTP: FFAuthProvider;
+    static OAUTH: FFAuthProvider;
+    constructor(id: string, o?: BaseEnumOptions);
 }

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/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,4 +9,4 @@ export declare const mergeRoles: (existing: string[], newOnes: string[] | undefi
     roles: string[];
     changed: boolean;
 };
-export declare const initRoleFromEnv: (log: Log, userEntity: ClassType<KitAuthUser>, envValue: 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

@@ -1,6 +1,6 @@
 import { repo } from 'remult';
 import { cyan, green, Log, yellow } 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

package/esm/auth/client/Auth.js

@@ -86,7 +86,7 @@ export class Auth {
      * _(popup example should work too, and a nice example/componant would be appreciated)_
      */
     static async signInOAuthGetUrl(o) {
-        return await Auth.signInOAuthGetUrlFn(o.provider, o.options, o.redirect);
+        return await Auth.signInOAuthGetUrlFn(o);
     }
 }
 __decorate([

package/esm/auth/index.d.ts

@@ -4,32 +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 { AuthProvider, 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 };
+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>;
@@ -111,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;