@vitnode/core 1.2.0-canary.10

package/dist/src/api/models/session-admin.js

@@ -0,0 +1,73 @@
+import { and, eq, gt, or } from "drizzle-orm";
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { HTTPException } from "hono/http-exception";
+import { core_admin_permissions, core_admin_sessions } from "../../database/admins";
+import { CONFIG } from "../../lib/config";
+import { UserModel } from "./user";
+export class SessionAdminModel {
+    constructor(c){
+        this.c = c;
+    }
+    c;
+    async checkIfUserIsAdmin(userId) {
+        const user = await new UserModel().getUserById({
+            id: userId,
+            c: this.c
+        });
+        if (!user) return false;
+        const [permission] = await this.c.get('db').select().from(core_admin_permissions).where(or(eq(core_admin_permissions.userId, user.id), eq(core_admin_permissions.roleId, user.roleId))).limit(1);
+        return !!permission;
+    }
+    async createSessionByUserId(userId) {
+        const isAdmin = await this.checkIfUserIsAdmin(userId);
+        if (!isAdmin) throw new HTTPException(403);
+        // Generate secure random bytes using Web Crypto API
+        const randomBytes = new Uint8Array(64);
+        crypto.getRandomValues(randomBytes);
+        const token = Array.from(randomBytes).map((b)=>b.toString(16).padStart(2, '0')).join('');
+        const deviceId = this.c.get('deviceId');
+        await this.c.get('db').insert(core_admin_sessions).values({
+            token,
+            userId,
+            expiresAt: new Date(Date.now() + this.c.get('core').authorization.adminCookieExpires),
+            deviceId
+        });
+        setCookie(this.c, this.c.get('core').authorization.adminCookieName, token, {
+            httpOnly: true,
+            secure: this.c.get('core').authorization.cookieSecure,
+            path: '/admin',
+            expires: new Date(Date.now() + this.c.get('core').authorization.adminCookieExpires),
+            domain: CONFIG.frontend.hostname
+        });
+        return {
+            token,
+            deviceId
+        };
+    }
+    async deleteSession() {
+        const token = getCookie(this.c, this.c.get('core').authorization.adminCookieName);
+        if (!token) return;
+        await this.c.get('db').delete(core_admin_sessions).where(eq(core_admin_sessions.token, token));
+        deleteCookie(this.c, this.c.get('core').authorization.adminCookieName, {
+            path: '/admin'
+        });
+    }
+    async getUser() {
+        const { authorization } = this.c.get('core');
+        const token = getCookie(this.c, authorization.adminCookieName);
+        if (!token) return null;
+        const deviceId = this.c.get('deviceId');
+        if (!deviceId) return null;
+        const [session] = await this.c.get('db').select({
+            token: core_admin_sessions.token,
+            userId: core_admin_sessions.userId
+        }).from(core_admin_sessions).where(and(eq(core_admin_sessions.token, token), eq(core_admin_sessions.deviceId, deviceId), gt(core_admin_sessions.expiresAt, new Date()))).limit(1);
+        if (!session) return null;
+        const user = await new UserModel().getUserById({
+            id: session.userId,
+            c: this.c
+        });
+        if (!user) return null;
+        return user;
+    }
+}

package/dist/src/api/models/session.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from 'hono';
+export declare class SessionModel {
+    constructor(c: Context);
+    protected readonly c: Context;
+    createSessionByUserId(userId: number): Promise<{
+        token: string;
+        deviceId: number;
+    }>;
+    deleteSession(): Promise<void>;
+    getUser(): Promise<{
+        id: number;
+        email: string;
+        name: string;
+        nameCode: string;
+        createdAt: Date;
+        newsletter: boolean;
+        avatarColor: string;
+        emailVerified: boolean;
+        roleId: number;
+        birthday: Date | null;
+    } | null>;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/src/api/models/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/api/models/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAUpC,qBAAa,YAAY;gBACX,CAAC,EAAE,OAAO;IAGtB,SAAS,CAAC,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IAExB,qBAAqB,CAAC,MAAM,EAAE,MAAM;;;;IAqCpC,aAAa;IAcb,OAAO;;;;;;;;;;;;CAoCd"}

package/dist/src/api/models/session.js

@@ -0,0 +1,60 @@
+import { and, eq, gt } from "drizzle-orm";
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { core_sessions } from "../../database/sessions";
+import { CONFIG } from "../../lib/config";
+import { UserModel } from "./user";
+export class SessionModel {
+    constructor(c){
+        this.c = c;
+    }
+    c;
+    async createSessionByUserId(userId) {
+        // Generate secure random bytes using Web Crypto API
+        const randomBytes = new Uint8Array(64);
+        crypto.getRandomValues(randomBytes);
+        const token = Array.from(randomBytes).map((b)=>b.toString(16).padStart(2, '0')).join('');
+        const deviceId = this.c.get('deviceId');
+        await this.c.get('db').insert(core_sessions).values({
+            token,
+            userId,
+            expiresAt: new Date(Date.now() + this.c.get('core').authorization.cookie_expires),
+            deviceId
+        });
+        setCookie(this.c, this.c.get('core').authorization.cookieName, token, {
+            httpOnly: true,
+            secure: this.c.get('core').authorization.cookieSecure,
+            path: '/',
+            expires: this.c.get('core').authorization.cookie_expires > 0 ? new Date(Date.now() + this.c.get('core').authorization.cookie_expires) : undefined,
+            domain: CONFIG.frontend.hostname
+        });
+        return {
+            token,
+            deviceId
+        };
+    }
+    async deleteSession() {
+        const token = getCookie(this.c, this.c.get('core').authorization.cookieName);
+        if (!token) return;
+        await this.c.get('db').delete(core_sessions).where(eq(core_sessions.token, token));
+        deleteCookie(this.c, this.c.get('core').authorization.cookieName);
+    }
+    async getUser() {
+        const token = getCookie(this.c, this.c.get('core').authorization.cookieName);
+        if (!token) return null;
+        const deviceId = this.c.get('deviceId');
+        if (!deviceId) return null;
+        const [session] = await this.c.get('db').select({
+            token: core_sessions.token,
+            userId: core_sessions.userId
+        }).from(core_sessions).where(and(eq(core_sessions.token, token), eq(core_sessions.deviceId, deviceId), gt(core_sessions.expiresAt, new Date()))).limit(1);
+        if (!session || session.token !== token) {
+            return null;
+        }
+        const user = await new UserModel().getUserById({
+            id: session.userId,
+            c: this.c
+        });
+        if (!user) return null;
+        return user;
+    }
+}

package/dist/src/api/models/sso.d.ts

@@ -0,0 +1,38 @@
+import type { Context } from 'hono';
+export interface SSOApiPlugin {
+    fetchToken: (code: string) => Promise<{
+        access_token: string;
+        token_type: string;
+    }>;
+    fetchUser: (args: {
+        access_token: string;
+        token_type: string;
+    }) => Promise<{
+        email: string;
+        id: string;
+        username: string;
+    }>;
+    getUrl: (props: {
+        state: string;
+    }) => string;
+    id: string;
+    name: string;
+}
+export declare const getRedirectUri: (code: string) => string;
+export declare class SSOModel {
+    constructor(c: Context);
+    private readonly c;
+    private readonly plugins;
+    private readonly signUpUser;
+    callback({ code, providerId, state, }: {
+        code: string;
+        providerId: string;
+        state: string;
+    }): Promise<{
+        userId: number;
+    }>;
+    encryptState(): Promise<string>;
+    getUrl(providerId: string): Promise<string>;
+    verifyState(state: string): Promise<void>;
+}
+//# sourceMappingURL=sso.d.ts.map

package/dist/src/api/models/sso.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sso.d.ts","sourceRoot":"","sources":["../../../../src/api/models/sso.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAapC,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,CACV,IAAI,EAAE,MAAM,KACT,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,SAAS,EAAE,CAAC,IAAI,EAAE;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,KAAK,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/D,MAAM,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC;IAC7C,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,WACqB,CAAC;AAEjE,qBAAa,QAAQ;gBACP,CAAC,EAAE,OAAO;IAKtB,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAU;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IAEzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CA6BzB;IAEI,QAAQ,CAAC,EACb,IAAI,EACJ,UAAU,EACV,KAAK,GACN,EAAE;QACD,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;KACf,GAAG,OAAO,CAAC;QACV,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IA+DI,YAAY;IA2BZ,MAAM,CAAC,UAAU,EAAE,MAAM;IASzB,WAAW,CAAC,KAAK,EAAE,MAAM;CA+BhC"}

package/dist/src/api/models/sso.js

@@ -0,0 +1,120 @@
+import crypto from "crypto";
+import { and, eq } from "drizzle-orm";
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { HTTPException } from "hono/http-exception";
+import { core_users, core_users_sso } from "../../database/users";
+import { CONFIG } from "../../lib/config";
+import { removeSpecialCharacters } from "../../lib/special-characters";
+import { UserModel } from "./user";
+export const getRedirectUri = (code)=>new URL(`${CONFIG.frontend.href}login/sso/${code}`).toString();
+export class SSOModel {
+    constructor(c){
+        this.c = c;
+        this.plugins = c.get('core').authorization.ssoPlugins;
+    }
+    c;
+    plugins;
+    signUpUser = async ({ providerId, user, c })=>{
+        const data = await new UserModel().signUp({
+            email: user.email,
+            name: removeSpecialCharacters(user.username, false),
+            newsletter: false,
+            hashedPassword: undefined
+        }, c);
+        await c.get('db').insert(core_users_sso).values({
+            userId: data.id,
+            providerId: providerId,
+            providerAccountId: user.id
+        });
+        return {
+            userId: data.id
+        };
+    };
+    async callback({ code, providerId, state }) {
+        await this.verifyState(state);
+        const provider = this.plugins.find((p)=>p.id === providerId);
+        if (!provider) {
+            throw new HTTPException(404);
+        }
+        const ssoToken = await provider.fetchToken(code);
+        const userFromSSO = await provider.fetchUser(ssoToken);
+        return await this.c.get('db').transaction(async (tx)=>{
+            const [dataSSOFromDb] = await tx.select({
+                userId: core_users_sso.userId
+            }).from(core_users_sso).leftJoin(core_users, eq(core_users.id, core_users_sso.userId)).where(and(eq(core_users_sso.providerId, providerId), eq(core_users_sso.providerAccountId, userFromSSO.id))).limit(1);
+            if (!dataSSOFromDb) {
+                const [userWithEmail] = await tx.select({
+                    id: core_users.id,
+                    email: core_users.email
+                }).from(core_users).where(eq(core_users.email, userFromSSO.email)).limit(1);
+                if (!userWithEmail) {
+                    const signUpUser = await this.signUpUser({
+                        providerId,
+                        user: userFromSSO,
+                        c: this.c
+                    });
+                    return signUpUser;
+                }
+                // If email exists, register SSO
+                await tx.insert(core_users_sso).values({
+                    providerId: providerId,
+                    providerAccountId: userFromSSO.id,
+                    userId: userWithEmail.id
+                });
+                return {
+                    userId: userWithEmail.id
+                };
+            }
+            return {
+                userId: dataSSOFromDb.userId
+            };
+        });
+    }
+    async encryptState() {
+        const state = crypto.randomBytes(8).toString('hex');
+        const encryptedState = await new Promise((resolve, reject)=>{
+            const salt = crypto.randomBytes(4).toString('hex');
+            crypto.scrypt(state, salt, 16, (err, derivedKey)=>{
+                if (err) reject(err);
+                resolve(salt + ':' + derivedKey.toString('hex'));
+            });
+        });
+        setCookie(this.c, `${this.c.get('core').authorization.cookieName}--state-sso`, encryptedState, {
+            httpOnly: true,
+            secure: this.c.get('core').authorization.cookieSecure,
+            path: '/',
+            domain: CONFIG.frontend.hostname
+        });
+        return state;
+    }
+    async getUrl(providerId) {
+        const provider = this.plugins.find((p)=>p.id === providerId);
+        if (!provider) {
+            throw new HTTPException(404);
+        }
+        return provider.getUrl({
+            state: await this.encryptState()
+        });
+    }
+    async verifyState(state) {
+        const storedState = getCookie(this.c, `${this.c.get('core').authorization.cookieName}--state-sso`);
+        if (!storedState) {
+            throw new HTTPException(400, {
+                message: 'Invalid state'
+            });
+        }
+        const isValid = await new Promise((resolve, reject)=>{
+            const [salt, storedHash] = storedState.split(':');
+            crypto.scrypt(state, salt, 16, (err, derivedKey)=>{
+                if (err) reject(err);
+                resolve(storedHash === derivedKey.toString('hex'));
+            });
+        });
+        if (!isValid) {
+            throw new HTTPException(400, {
+                message: 'Invalid state'
+            });
+        }
+        deleteCookie(this.c, `${this.c.get('core').authorization.cookieName}--state-sso`);
+    }
+}

package/dist/src/api/models/user/get-user-by-id.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from 'hono';
+export declare const getUserById: ({ id, c }: {
+    c: Context;
+    id: number;
+}) => Promise<{
+    id: number;
+    email: string;
+    name: string;
+    nameCode: string;
+    createdAt: Date;
+    newsletter: boolean;
+    avatarColor: string;
+    emailVerified: boolean;
+    roleId: number;
+    birthday: Date | null;
+} | null>;
+//# sourceMappingURL=get-user-by-id.d.ts.map

package/dist/src/api/models/user/get-user-by-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-user-by-id.d.ts","sourceRoot":"","sources":["../../../../../src/api/models/user/get-user-by-id.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAMpC,eAAO,MAAM,WAAW,GAAU,WAAW;IAAE,CAAC,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;SAqBtE,CAAC"}

package/dist/src/api/models/user/get-user-by-id.js

@@ -0,0 +1,18 @@
+import { eq } from "drizzle-orm";
+import { core_users } from "../../../database/users";
+export const getUserById = async ({ id, c })=>{
+    const [user] = await c.get('db').select({
+        id: core_users.id,
+        email: core_users.email,
+        name: core_users.name,
+        nameCode: core_users.nameCode,
+        createdAt: core_users.createdAt,
+        newsletter: core_users.newsletter,
+        avatarColor: core_users.avatarColor,
+        emailVerified: core_users.emailVerified,
+        roleId: core_users.roleId,
+        birthday: core_users.birthday
+    }).from(core_users).where(eq(core_users.id, id)).limit(1);
+    if (!user) return null;
+    return user;
+};

package/dist/src/api/models/user/sign-in-with-passwords.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from 'hono';
+export declare const signInWithPassword: ({ email, password, c, }: {
+    c: Context;
+    email: string;
+    password: string;
+}) => Promise<{
+    id: number;
+    email: string;
+}>;
+//# sourceMappingURL=sign-in-with-passwords.d.ts.map

package/dist/src/api/models/user/sign-in-with-passwords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-in-with-passwords.d.ts","sourceRoot":"","sources":["../../../../../src/api/models/user/sign-in-with-passwords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AASpC,eAAO,MAAM,kBAAkB,GAAU,yBAItC;IACD,CAAC,EAAE,OAAO,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;;;EA0BA,CAAC"}

package/dist/src/api/models/user/sign-in-with-passwords.js

@@ -0,0 +1,22 @@
+import { eq } from "drizzle-orm";
+import { HTTPException } from "hono/http-exception";
+import { core_users } from "../../../database/users";
+import { PasswordModel } from "../password";
+export const signInWithPassword = async ({ email, password, c })=>{
+    const [user] = await c.get('db').select({
+        id: core_users.id,
+        email: core_users.email,
+        password: core_users.password
+    }).from(core_users).where(eq(core_users.email, email)).limit(1);
+    if (!user?.password) {
+        throw new HTTPException(403);
+    }
+    const validPassword = await new PasswordModel().verifyPassword(password, user.password);
+    if (!validPassword) {
+        throw new HTTPException(403);
+    }
+    return {
+        id: user.id,
+        email: user.email
+    };
+};

package/dist/src/api/models/user/sign-up.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from 'hono';
+export declare const signUp: ({ email, name, newsletter, hashedPassword, }: {
+    email: string;
+    hashedPassword: string | undefined;
+    name: string;
+    newsletter?: boolean;
+}, c: Context) => Promise<{
+    id: number;
+    ipAddress: string;
+    name: string;
+    nameCode: string;
+    email: string;
+    createdAt: Date;
+    newsletter: boolean;
+    avatarColor: string;
+    emailVerified: boolean;
+    roleId: number;
+    birthday: Date | null;
+    language: string;
+}>;
+//# sourceMappingURL=sign-up.d.ts.map

package/dist/src/api/models/user/sign-up.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-up.d.ts","sourceRoot":"","sources":["../../../../../src/api/models/user/sign-up.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAmEpC,eAAO,MAAM,MAAM,GACjB,8CAKG;IACD,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,EACD,GAAG,OAAO;;;;;;;;;;;;;EAwDX,CAAC"}

package/dist/src/api/models/user/sign-up.js

@@ -0,0 +1,75 @@
+import { and, count, eq, or } from "drizzle-orm";
+import { HTTPException } from "hono/http-exception";
+import { getUserIp } from "../../lib/get-user-ip";
+import { generateAvatarColor } from "../../modules/users/avatar-color";
+import { core_roles } from "../../../database/roles";
+import { core_users } from "../../../database/users";
+import { removeSpecialCharacters } from "../../../lib/special-characters";
+const getDefaultData = async (c)=>{
+    const [countUsers] = await c.get('db').select({
+        count: count()
+    }).from(core_users);
+    // If no users, return root group
+    if (countUsers.count === 0) {
+        const [defaultRole] = await c.get('db').select({
+            id: core_roles.id
+        }).from(core_roles).where(and(eq(core_roles.default, false), eq(core_roles.root, true))).limit(1);
+        if (!defaultRole) {
+            throw new HTTPException(400, {
+                message: 'Default group not found.'
+            });
+        }
+        return {
+            roleId: defaultRole.id,
+            emailVerified: true
+        };
+    }
+    const [defaultRole] = await c.get('db').select({
+        id: core_roles.id
+    }).from(core_roles).where(and(eq(core_roles.default, true), eq(core_roles.root, false))).limit(1);
+    if (!defaultRole) {
+        throw new HTTPException(400, {
+            message: 'Default role not found.'
+        });
+    }
+    return {
+        roleId: defaultRole.id,
+        // TODO: Handle email verification
+        emailVerified: false
+    };
+};
+export const signUp = async ({ email, name, newsletter, hashedPassword }, c)=>{
+    const convertToNameSEO = removeSpecialCharacters(name);
+    const checkIfUserExist = await c.get('db').select({
+        email: core_users.email,
+        name_code: core_users.nameCode
+    }).from(core_users).where(or(eq(core_users.email, email), eq(core_users.nameCode, convertToNameSEO)));
+    const findEmail = checkIfUserExist.find((user)=>user.email === email);
+    if (findEmail) {
+        throw new HTTPException(400, {
+            message: 'Email already exists'
+        });
+    }
+    const findName = checkIfUserExist.find((user)=>user.name_code === convertToNameSEO);
+    if (findName) {
+        throw new HTTPException(400, {
+            message: 'Name already exists'
+        });
+    }
+    const { roleId, emailVerified } = await getDefaultData(c);
+    const [data] = await c.get('db').insert(core_users).values({
+        email,
+        name,
+        nameCode: convertToNameSEO,
+        // TODO: Handle newsletter only if email is allowed
+        newsletter,
+        password: hashedPassword,
+        avatarColor: generateAvatarColor(name),
+        roleId,
+        emailVerified,
+        ipAddress: getUserIp(c)
+    }).returning();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { password: _, ...user } = data;
+    return user;
+};

package/dist/src/api/models/user.d.ts

@@ -0,0 +1,45 @@
+export declare class UserModel {
+    getUserById: ({ id, c }: {
+        c: import("hono").Context;
+        id: number;
+    }) => Promise<{
+        id: number;
+        email: string;
+        name: string;
+        nameCode: string;
+        createdAt: Date;
+        newsletter: boolean;
+        avatarColor: string;
+        emailVerified: boolean;
+        roleId: number;
+        birthday: Date | null;
+    } | null>;
+    signInWithPassword: ({ email, password, c, }: {
+        c: import("hono").Context;
+        email: string;
+        password: string;
+    }) => Promise<{
+        id: number;
+        email: string;
+    }>;
+    signUp: ({ email, name, newsletter, hashedPassword, }: {
+        email: string;
+        hashedPassword: string | undefined;
+        name: string;
+        newsletter?: boolean;
+    }, c: import("hono").Context) => Promise<{
+        id: number;
+        ipAddress: string;
+        name: string;
+        nameCode: string;
+        email: string;
+        createdAt: Date;
+        newsletter: boolean;
+        avatarColor: string;
+        emailVerified: boolean;
+        roleId: number;
+        birthday: Date | null;
+        language: string;
+    }>;
+}
+//# sourceMappingURL=user.d.ts.map

package/dist/src/api/models/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../../src/api/models/user.ts"],"names":[],"mappings":"AAIA,qBAAa,SAAS;IACpB,WAAW;;;;;;;;;;;;;;cAAe;IAC1B,kBAAkB;;;;;;;OAAsB;IACxC,MAAM;;;;kBAEw7C,CAAC;;;;;;;;;;;;;;OAF/6C;CACjB"}

package/dist/src/api/models/user.js

@@ -0,0 +1,8 @@
+import { getUserById } from "./user/get-user-by-id";
+import { signInWithPassword } from "./user/sign-in-with-passwords";
+import { signUp } from "./user/sign-up";
+export class UserModel {
+    getUserById = getUserById;
+    signInWithPassword = signInWithPassword;
+    signUp = signUp;
+}