firstly 0.0.1 → 0.0.3

package/esm/api/index.d.ts

@@ -0,0 +1,42 @@
+import { type Handle, type MaybePromise, type RequestEvent } from '@sveltejs/kit';
+import { type ClassType } from 'remult';
+import type { RemultServerOptions } from 'remult/server';
+import { type MailOptions } from '../mail';
+export type Module = {
+    /**
+     * The name of the module (usefull for logging and debugging purposes)
+     */
+    name: string;
+    index?: number;
+    entities?: ClassType<any>[];
+    controllers?: ClassType<any>[];
+    initApi?: RemultServerOptions<RequestEvent>['initApi'];
+    initRequest?: RemultServerOptions<RequestEvent>['initRequest'];
+    handlePreRemult?: Handle;
+    handlePosRemult?: Handle;
+    earlyReturn?: (input: Parameters<Handle>[0]) => MaybePromise<{
+        early: false;
+        resolve?: never;
+    } | {
+        early: true;
+        resolve: ReturnType<Handle>;
+    }>;
+    modules?: Module[];
+};
+type Options = Omit<RemultServerOptions<RequestEvent<Partial<Record<string, string>>, string | null>> & {
+    modules?: Module[] | undefined;
+    mail?: MailOptions;
+}, 'entities' | 'controllers' | 'initRequest' | 'initApi'>;
+/**
+ * it's basically `remultSveltekit` with the `modules` option
+ */
+export declare const firstly: (o: Options) => {
+    modulesSorted: Module[];
+    entities: ClassType<any>[];
+    server: import("remult/remult-sveltekit").RemultSveltekitServer;
+};
+/**
+ * Full flat and ordered list by index and concatenaining the modules name
+ */
+export declare const modulesFlatAndOrdered: (modules: Module[]) => Module[];
+export {};

package/esm/api/index.js

@@ -0,0 +1,97 @@
+import {} from '@sveltejs/kit';
+import nodemailer from 'nodemailer';
+import { remult } from 'remult';
+import { remultSveltekit } from 'remult/remult-sveltekit';
+import { Log } from '@kitql/helpers';
+import { building } from '$app/environment';
+import { mailInit } from '../mail';
+/**
+ * it's basically `remultSveltekit` with the `modules` option
+ */
+export const firstly = (o) => {
+    const modulesSorted = modulesFlatAndOrdered(o.modules ?? []);
+    const entities = modulesSorted.flatMap((m) => m.entities ?? []);
+    mailInit(nodemailer, o.mail);
+    return {
+        modulesSorted: modulesSorted,
+        entities,
+        server: remultSveltekit({
+            // Changing the default default of remult
+            logApiEndPoints: false,
+            admin: true,
+            defaultGetLimit: 25,
+            error: o.error
+                ? o.error
+                : async (e) => {
+                    // if 500 we move to 501 to avoid the default retry mechanism
+                    if (e.httpStatusCode == 500) {
+                        e.sendError(501, e.responseBody);
+                    }
+                },
+            // Add user configuration
+            ...o,
+            // Module part
+            entities,
+            controllers: modulesSorted.flatMap((m) => m.controllers ?? []),
+            initRequest: async (kitEvent, op) => {
+                // usefull for later...
+                remult.context.url = kitEvent.url;
+                for (let i = 0; i < modulesSorted.length; i++) {
+                    const f = modulesSorted[i].initRequest;
+                    if (f) {
+                        try {
+                            await f(kitEvent, op);
+                        }
+                        catch (error) {
+                            const log = new Log(`firstly | ${modulesSorted[i].name}`);
+                            log.error(error);
+                        }
+                    }
+                }
+                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) {
+                    for (let i = 0; i < modulesSorted.length; i++) {
+                        const f = modulesSorted[i].initApi;
+                        if (f) {
+                            try {
+                                await f(r);
+                            }
+                            catch (error) {
+                                const log = new Log(`firstly | ${modulesSorted[i].name}`);
+                                log.error(error);
+                            }
+                        }
+                    }
+                }
+            },
+        }),
+    };
+};
+/**
+ * Full flat and ordered list by index and concatenaining the modules name
+ */
+export const modulesFlatAndOrdered = (modules) => {
+    const flattenModules = (modules, parentName = '') => {
+        return modules.reduce((acc, module) => {
+            const fullName = parentName ? `${parentName}-${module.name}` : module.name;
+            // Create a new module object without the 'modules' property
+            const { modules: _, ...flatModule } = module;
+            const newModule = { ...flatModule, name: fullName };
+            const subModules = module.modules ? flattenModules(module.modules, fullName) : [];
+            return [...acc, newModule, ...subModules];
+        }, []);
+    };
+    const flatModules = flattenModules(modules);
+    flatModules.sort((a, b) => (a.index || 0) - (b.index || 0));
+    return flatModules;
+};

package/esm/auth/Adapter.d.ts

@@ -0,0 +1,10 @@
+import type { Adapter, DatabaseSession, DatabaseUser } from 'lucia';
+export declare class RemultLuciaAdapter implements Adapter {
+    getSessionAndUser(sessionId: string): Promise<[session: DatabaseSession | null, user: DatabaseUser | null]>;
+    getUserSessions(userId: string): Promise<DatabaseSession[]>;
+    setSession(session: DatabaseSession): Promise<void>;
+    updateSessionExpiration(sessionId: string, expiresAt: Date): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+    deleteUserSessions(userId: string): Promise<void>;
+    deleteExpiredSessions(): Promise<void>;
+}

package/esm/auth/Adapter.js

@@ -0,0 +1,54 @@
+import { remult } from 'remult';
+import { getSafeOptions } from './index.js';
+export class RemultLuciaAdapter {
+    async getSessionAndUser(sessionId) {
+        const oSafe = getSafeOptions();
+        const session = await remult.repo(oSafe.Session).findId(sessionId);
+        if (session) {
+            const user = await remult.repo(oSafe.User).findId(session.userId);
+            return [
+                { ...session, attributes: {} },
+                {
+                    ...user,
+                    attributes: {
+                        ...user,
+                        session: { id: session.id, expiresAt: session.expiresAt },
+                    },
+                },
+            ];
+        }
+        return [null, null];
+    }
+    async getUserSessions(userId) {
+        const oSafe = getSafeOptions();
+        return (await remult.repo(oSafe.Session).find({ where: { userId } })).map((s) => {
+            return { ...s, attributes: {} };
+        });
+    }
+    async setSession(session) {
+        const oSafe = getSafeOptions();
+        await remult.repo(oSafe.Session).insert(session);
+    }
+    async updateSessionExpiration(sessionId, expiresAt) {
+        const oSafe = getSafeOptions();
+        await remult.repo(oSafe.Session).update(sessionId, { expiresAt });
+    }
+    async deleteSession(sessionId) {
+        const oSafe = getSafeOptions();
+        await remult.repo(oSafe.Session).delete(sessionId);
+    }
+    async deleteUserSessions(userId) {
+        const oSafe = getSafeOptions();
+        const all = await remult.repo(oSafe.Session).find({ where: { userId } });
+        for (const s of all) {
+            await remult.repo(oSafe.Session).delete(s);
+        }
+    }
+    async deleteExpiredSessions() {
+        const oSafe = getSafeOptions();
+        const all = await remult.repo(oSafe.Session).find({ where: { expiresAt: { $lt: new Date() } } });
+        for (const s of all) {
+            await remult.repo(oSafe.Session).delete(s);
+        }
+    }
+}

package/esm/auth/AuthController.d.ts

@@ -0,0 +1,59 @@
+import { type AuthorizationURLOptions } from '.';
+export declare class AuthController {
+    /**
+     * Sign out the current user
+     */
+    static signOut(): Promise<void>;
+    /**
+     * Sign in with a demo account
+     * _(The easiest way to demo & test your application)_
+     */
+    static signInDemo(name: string): Promise<string>;
+    /**
+     * This is for login / password authentication SignUp
+     * _(The first param `name` can be "anything")_
+     */
+    static invite(email: string): Promise<"Mail sent !" | "Demo Mail sent !" | "ok">;
+    /**
+     * This is for login / password authentication SignUp
+     * _(The first param `email` can be "anything")_
+     */
+    static signUpPassword(email: string, password: string): Promise<string>;
+    /**
+     * This is for login / password authentication SignIn
+     * _(The first param `email` can be "anything")_
+     */
+    static signInPassword(email: string, password: string): Promise<string>;
+    /**
+     * Forgot your password ? Send a mail to reset it.
+     */
+    static forgotPassword(email: string): Promise<"Mail sent !" | "Demo Mail sent !">;
+    /**
+     * Reset your password with a token
+     */
+    static resetPassword(token: string, password: string): Promise<string>;
+    /** OTP */
+    static signInOTP(email: string): Promise<"Mail sent !" | "Hum, something went wrong !">;
+    /**
+     * Verify the OTP code
+     */
+    static verifyOtp(email: string, otp: string | number): Promise<string>;
+    /** 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 AuthController.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<string>;
+}