nuxt-authenticate-module 1.0.0

package/dist/runtime/page/UserRegister.vue

@@ -0,0 +1,150 @@
+<script setup>
+import * as z from "zod";
+import { useFetchError } from "../utility";
+const fields = [{
+  name: "userName",
+  type: "text",
+  label: "Nombre de usuario",
+  description: "El nombre de usuario se utilizar\xE1 para iniciar sesi\xF3n",
+  placeholder: "Ingresa tu nombre de usuario",
+  required: true,
+  ui: {
+    wrapper: "mb-6"
+  }
+}, {
+  name: "password",
+  label: "Contrase\xF1a",
+  type: "password",
+  placeholder: "Ejemplo: @MiContrase\xF1a01",
+  required: true
+}, {
+  name: "password2",
+  label: "Repetir Contrase\xF1a",
+  type: "password",
+  placeholder: "Ingresa de nuevo la contrase\xF1a",
+  required: true
+}, {
+  name: "name",
+  label: "Nombre",
+  type: "text",
+  placeholder: "Nombre",
+  required: true
+}, {
+  name: "lastName",
+  label: "Apellido",
+  type: "text",
+  placeholder: "Apellido",
+  help: "",
+  required: true
+}, {
+  name: "personId",
+  label: "C\xE9dula",
+  type: "text",
+  placeholder: "7-777-7777",
+  required: true
+}];
+const personIdRegex = /^\d{1,4}-\d{1,4}-\d{1,4}$/;
+const schema = z.object({
+  userName: z.string("Nombre de usuario requerido").nonempty("Nombre de usuario requerido"),
+  password: z.string("Contrase\xF1a obligatoria").min(8, "La contrase\xF1a debe tener al menos 8 caracteres").regex(/(?=.*[a-z])/, "Debe contener al menos una letra min\xFAscula").regex(/(?=.*[A-Z])/, "Debe contener al menos una letra may\xFAscula").regex(/(?=.*\d)/, "Debe contener al menos un n\xFAmero").regex(/(?=.*[@$!%*?&])/, "Debe contener al menos un car\xE1cter especial (@$!%*?&)"),
+  password2: z.string("Confirme la contrase\xF1a"),
+  name: z.string("Nombre requerido").min(3, "El nombre de usuairo debe contener al menos 3 caracteres"),
+  lastName: z.string("Apellido requerido").min(3, "El apellido debe contener al menos 3 caracteres"),
+  personId: z.string("C\xE9dula requerida").regex(personIdRegex, "Formato de c\xE9dula inv\xE1lida")
+}).refine((data) => data.password === data.password2, {
+  message: "Las contrase\xF1as no coinciden",
+  path: ["password2"]
+  // Marca el error en el campo "password2"
+});
+const errorRef = useFetchError();
+async function onSubmit(payload) {
+  try {
+    const res = await $fetch("/api/auth/register", {
+      method: "POST",
+      body: {
+        userName: payload.data.userName,
+        password: payload.data.password,
+        name: payload.data.name,
+        lastName: payload.data.lastName,
+        personId: payload.data.personId
+      }
+    });
+    useToast().add({
+      color: "success",
+      title: `(${res.userName}) registrado con \xE9xito`
+    });
+    await useRouter().push("/login");
+  } catch (error) {
+    const fetchError = error;
+    errorRef.value = fetchError;
+  }
+}
+</script>
+
+<template>
+  <div
+    class="flex items-center justify-center"
+    :style="{
+  minHeight: '100vh'
+}"
+  >
+    <UPageCard class="w-full max-w-md">
+      <UAuthForm
+        :schema="schema"
+        :fields="fields"
+        title="Registro de Usuario"
+        icon="i-lucide-lock"
+        :submit="{
+  label: 'Registrar usuario',
+  class: 'cursor-pointer'
+}"
+        :separator="{
+  icon: 'i-lucide-user'
+}"
+        @submit="onSubmit"
+      >
+        <template #description>
+          <span>Registro de usuario Salva Mar SA</span>
+        </template>
+        <template #providers>
+          <UBadge
+            color="warning"
+            variant="soft"
+            size="lg"
+          >
+            <span class="text-center">
+              El usuario debe ser habilitado por el administrador del sistema luego del registro
+            </span>
+          </UBadge>
+        </template>
+        <template #password-description>
+          <ClientOnly>
+            <div>La contraseña debe cumplir con: </div>
+            <ul>
+              <li> ✓ Mínimo 8 caracteres</li>
+              <li> ✓ Al menos una letra minúscula</li>
+              <li> ✓ Al menos una letra mayúscula</li>
+              <li> ✓ Al menos un carácter especial (@$!%*?&)</li>
+              <li> ✓ Al menos un número [0-9]</li>
+            </ul>
+          </ClientOnly>
+        </template>
+        <template #validation>
+          <UAlert
+            v-if="errorRef"
+            color="error"
+            icon="i-lucide-info"
+            :title="`Error ${errorRef.statusCode}`"
+            :description="errorRef.data.message"
+          />
+        </template>
+        <template #footer>
+          <ULink
+            to="/login"
+            class="text-primary font-medium"
+          >Ir a inicio de sesión</ULink>.
+        </template>
+      </UAuthForm>
+    </UPageCard>
+  </div>
+</template>

package/dist/runtime/page/UserRegister.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/server/api/auth/closeSession.post.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    message: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/auth/closeSession.post.js

@@ -0,0 +1,7 @@
+import { defineEventHandler } from "h3";
+import { getSessionRepository } from "utility";
+import { handleCloseSession } from "service";
+export default defineEventHandler(async (event) => {
+  const sessionRepository = getSessionRepository(event);
+  return await handleCloseSession(event, sessionRepository);
+});

package/dist/runtime/server/api/auth/login.post.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    id: number;
+    user: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/auth/login.post.js

@@ -0,0 +1,9 @@
+import { handleUserLogin } from "service";
+import { getSessionRepository, getUserRepository } from "utility";
+import { defineEventHandler, readBody } from "h3";
+export default defineEventHandler(async (event) => {
+  const user = await readBody(event);
+  const sessionRepository = getSessionRepository(event);
+  const userRepository = getUserRepository(event);
+  return await handleUserLogin(event, userRepository, user, sessionRepository);
+});

package/dist/runtime/server/api/auth/register.post.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    id: number;
+    userName: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/auth/register.post.js

@@ -0,0 +1,8 @@
+import { defineEventHandler, readBody } from "h3";
+import { getUserRepository } from "utility/getUserRepository";
+import { handleUserRegistration } from "service";
+export default defineEventHandler(async (event) => {
+  const user = await readBody(event);
+  const userRepository = getUserRepository(event);
+  return await handleUserRegistration(userRepository, user);
+});

package/dist/runtime/server/middleware/session.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/middleware/session.js

@@ -0,0 +1,16 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler(async (event) => {
+  const session = await getUserSession(event);
+  console.log(session.user?.sessionId, event.node.req.url);
+  if (session?.user?.sessionId) {
+    event.context.sessionId = session.user.sessionId;
+    console.log("Session ID set in context:", event.context.sessionId);
+    await replaceUserSession(event, {
+      user: {
+        name: session.user.name,
+        sessionId: session.user.sessionId,
+        activityTime: (/* @__PURE__ */ new Date()).getTime()
+      }
+    });
+  }
+});

package/dist/runtime/server/modules/auth/auth.errors.d.ts

@@ -0,0 +1,4 @@
+import { ErrorControler } from '../functions/errors/index.js';
+declare const authErrors: ErrorControler<"NO_TOKEN" | "INVALID_TOKEN" | "EXPIRED_TOKEN" | "UNAUTHORIZED" | "NO_REGISTER" | "INVALID_PASSWORD" | "USER_NOT_ENABLED">;
+type AuthErrorsCode = keyof typeof authErrors.errorMap;
+export { authErrors, AuthErrorsCode };

package/dist/runtime/server/modules/auth/auth.errors.js

@@ -0,0 +1,32 @@
+import { ErrorControler } from "../functions/errors/index.js";
+const authErrors = new ErrorControler({
+  NO_TOKEN: {
+    statusCode: 401,
+    message: "No se ha iniciado sesi\xF3n."
+  },
+  INVALID_TOKEN: {
+    statusCode: 401,
+    message: "Sesi\xF3n Inv\xE1lida."
+  },
+  EXPIRED_TOKEN: {
+    statusCode: 401,
+    message: "La sesi\xF3n a experado."
+  },
+  UNAUTHORIZED: {
+    statusCode: 403,
+    message: "Acceso no autorizado."
+  },
+  NO_REGISTER: {
+    statusCode: 404,
+    message: "El usuario no est\xE1 registrado."
+  },
+  INVALID_PASSWORD: {
+    statusCode: 401,
+    message: "Contrase\xF1a inv\xE1lida."
+  },
+  USER_NOT_ENABLED: {
+    statusCode: 403,
+    message: "El usuario no est\xE1 habilitado"
+  }
+});
+export { authErrors };

package/dist/runtime/server/modules/auth/auth.user.d.ts

@@ -0,0 +1,24 @@
+import type { User, IUserRepository } from 'modules/users';
+export interface LoginData {
+    userName: User['userName'];
+    password: User['password'];
+}
+/**
+ * Autentica a un usuario verificando que exis ta y que la contraseña proporcionada coincida con la almacenada.
+ * @param userRepository Repositorio de usuarios para acceder a los datos de los usuarios.
+ * @param user Datos de inicio de sesión que incluyen el nombre de usuario y la contraseña.
+ * @returns El registro del usuario autenticado obtenido de la base de datos.
+ * @throws {AuthError} Cuando el usuario no está registrado o la contraseña es inválida.
+ */
+export declare function authUser(userRepository: IUserRepository, user: LoginData): Promise<{
+    sessionId: number | null;
+    name: string;
+    userName: string;
+    password: string;
+    lastName: string;
+    personId: string;
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    enable: boolean;
+}>;

package/dist/runtime/server/modules/auth/auth.user.js

@@ -0,0 +1,10 @@
+import { authErrors } from "./auth.errors.js";
+import { comparePassword } from "../functions/utils/comparePassword.js";
+export async function authUser(userRepository, user) {
+  const uniqueUser = await userRepository.findUniqueByUserName(user.userName);
+  if (!uniqueUser) throw authErrors.error("NO_REGISTER");
+  if (!uniqueUser.enable) throw authErrors.error("USER_NOT_ENABLED");
+  const isMatch = await comparePassword(user.password, uniqueUser.password);
+  if (!isMatch) throw authErrors.error("INVALID_PASSWORD");
+  return uniqueUser;
+}

package/dist/runtime/server/modules/auth/index.d.ts

@@ -0,0 +1,2 @@
+export * from './auth.user.js';
+export * from './auth.errors.js';

package/dist/runtime/server/modules/auth/index.js

@@ -0,0 +1,2 @@
+export * from "./auth.user.js";
+export * from "./auth.errors.js";

package/dist/runtime/server/modules/functions/errors/errors.controler.d.ts

@@ -0,0 +1,6 @@
+import type { ErrorMap } from './errors.model.js';
+export declare class ErrorControler<T extends string> {
+    errorMap: ErrorMap<T>;
+    constructor(errorMap: ErrorMap<T>);
+    error(code: keyof ErrorMap<T>): import("h3").H3Error<unknown>;
+}

package/dist/runtime/server/modules/functions/errors/errors.controler.js

@@ -0,0 +1,15 @@
+import { createError } from "h3";
+export class ErrorControler {
+  errorMap;
+  constructor(errorMap) {
+    this.errorMap = errorMap;
+  }
+  error(code) {
+    return createError(
+      this.errorMap[code] || {
+        statusCode: 500,
+        message: "Internal Server Error"
+      }
+    );
+  }
+}

package/dist/runtime/server/modules/functions/errors/errors.model.d.ts

@@ -0,0 +1,10 @@
+export type ErrorCode<T extends string> = {
+  code: T
+}
+
+export type ErrorInfo = {
+  statusCode: number
+  message: string
+}
+
+export type ErrorMap<T extends string> = Record<T, ErrorInfo>

package/dist/runtime/server/modules/functions/errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './errors.controler.js';
+export type * from './errors.model';

package/dist/runtime/server/modules/functions/errors/index.js

@@ -0,0 +1 @@
+export * from "./errors.controler.js";

package/dist/runtime/server/modules/functions/utils/comparePassword.d.ts

@@ -0,0 +1 @@
+export declare function comparePassword(password: string, hash: string): Promise<boolean>;

package/dist/runtime/server/modules/functions/utils/comparePassword.js

@@ -0,0 +1,4 @@
+import bcrypt from "bcrypt";
+export async function comparePassword(password, hash) {
+  return await bcrypt.compare(password, hash);
+}

package/dist/runtime/server/modules/functions/utils/hashPassword.d.ts

@@ -0,0 +1 @@
+export declare function hashPassword(password: string): Promise<string>;

package/dist/runtime/server/modules/functions/utils/hashPassword.js

@@ -0,0 +1,4 @@
+import bcrypt from "bcrypt";
+export async function hashPassword(password) {
+  return await bcrypt.hash(password, 10);
+}

package/dist/runtime/server/modules/session/index.d.ts

@@ -0,0 +1,4 @@
+export * from './session.register.js';
+export * from './session.close.js';
+export * from './session.errors.js';
+export type * from './session.types';

package/dist/runtime/server/modules/session/index.js

@@ -0,0 +1,3 @@
+export * from "./session.register.js";
+export * from "./session.close.js";
+export * from "./session.errors.js";

package/dist/runtime/server/modules/session/session.close.d.ts

@@ -0,0 +1,12 @@
+import type { Session, ISessionRepository } from './session.types.js';
+/**
+ * Cierra todas las sesiones activas de un usuario específico.
+ *
+ * Esta función valida el payload del token y luego actualiza todas las sesiones
+ * activas del usuario estableciendo su fecha de expiración al momento actual,
+ * efectivamente cerrando todas las sesiones.
+ *
+ * @throws {Error} Lanza un error 'SESION_NO_VALID' si no se encuentran sesiones activas para cerrar
+ * @returns Una promesa que se resuelve cuando las sesiones han sido cerradas exitosamente
+ */
+export declare function sessionClose(sessionRepository: Partial<ISessionRepository>, sessionId: Session['id']): Promise<boolean>;

package/dist/runtime/server/modules/session/session.close.js

@@ -0,0 +1,7 @@
+import { sessionErrors } from "./session.errors.js";
+export async function sessionClose(sessionRepository, sessionId) {
+  if (!sessionRepository.sessionClose) throw sessionErrors.error("SESSION_REPOSITORY_SESSIONSCLOSE");
+  const affect = await sessionRepository.sessionClose(sessionId);
+  if (affect !== 1) throw sessionErrors.error("SESION_NO_VALID");
+  return true;
+}

package/dist/runtime/server/modules/session/session.errors.d.ts

@@ -0,0 +1,4 @@
+import { ErrorControler } from '../functions/errors/index.js';
+declare const sessionErrors: ErrorControler<"SESION_NO_VALID" | "SESSION_REPOSITORY_CREATESESSION" | "SESSION_REPOSITORY_SESSIONSCLOSE">;
+type SessionErrorsCode = keyof typeof sessionErrors.errorMap;
+export { sessionErrors, SessionErrorsCode };

package/dist/runtime/server/modules/session/session.errors.js

@@ -0,0 +1,16 @@
+import { ErrorControler } from "../functions/errors/index.js";
+const sessionErrors = new ErrorControler({
+  SESION_NO_VALID: {
+    statusCode: 401,
+    message: "La sesi\xF3n no es v\xE1lida o ha expirado."
+  },
+  SESSION_REPOSITORY_CREATESESSION: {
+    statusCode: 500,
+    message: "Error en el repositorio de sesiones al crear una sesi\xF3n."
+  },
+  SESSION_REPOSITORY_SESSIONSCLOSE: {
+    statusCode: 500,
+    message: "Error en el repositorio de sesiones al cerrar las sesiones."
+  }
+});
+export { sessionErrors };

package/dist/runtime/server/modules/session/session.register.d.ts

@@ -0,0 +1,21 @@
+import type { UserModel } from '../../../../../playground/generated/prisma/models.js';
+import type { ISessionRepository } from './session.types.js';
+/**
+ * Crea un nuevo registro de sesión en la base de datos para un usuario.
+ *
+ * @param sessionRepository - El repositorio de sesión para interactuar con la base de datos
+ * @param userId - El identificador único del usuario para crear una sesión
+ * @returns Una promesa que resuelve al objeto de sesión creado
+ *
+ * @example
+ * ```typescript
+ * const session = await sessionRegister(sessionRepository, 'user123');
+ * console.log(session.id); // ID de sesión
+ * ```
+ */
+export declare function sessionRegister(sessionRepository: Partial<ISessionRepository>, userId: UserModel['id']): Promise<{
+    id: number;
+    createdAt: Date;
+    userId: number;
+    expiresAt: Date | null;
+}>;

package/dist/runtime/server/modules/session/session.register.js

@@ -0,0 +1,5 @@
+import { sessionErrors } from "./session.errors.js";
+export async function sessionRegister(sessionRepository, userId) {
+  if (!sessionRepository.createSession) throw sessionErrors.error("SESSION_REPOSITORY_CREATESESSION");
+  return await sessionRepository.createSession(userId);
+}

package/dist/runtime/server/modules/session/session.types.d.ts

@@ -0,0 +1,31 @@
+import type { User } from 'modules/users'
+import type { Session } from '../../../../../playground/generated/prisma/client'
+
+export { Session }
+
+export interface SessionPayload {
+  sessionId: number
+  userId: number
+  userName: string
+}
+
+type rowsAffected = number
+/**
+ * Interfaz de repositorio para gestionar sesiones de usuario.
+ *
+ * Proporciona métodos para crear una nueva sesión para un usuario y cerrar una sesión existente.
+ *
+ * Notas:
+ * - Los tipos referenciados (User['id'], Session, rowsAffected) deben documentarse en sus declaraciones.
+ * - Sí: puedes comentar los tipos y sus miembros con TSDoc en sus propias declaraciones.
+ *
+ * @param createSession.userId - El identificador del usuario (User['id']).
+ * @returns Promesa que se resuelve con la Session creada.
+ *
+ * @param sessionClose.sessionId - El identificador de la sesión a cerrar (Session['id']).
+ * @returns Promesa que se resuelve con el número de filas afectadas (rowsAffected).
+ */
+export interface ISessionRepository {
+  createSession: (userId: User['id']) => Promise<Session>
+  sessionClose: (sessionId: Session['id']) => Promise<rowsAffected>
+}

package/dist/runtime/server/modules/users/index.d.ts

@@ -0,0 +1,5 @@
+export * from './user.validator.js';
+export * from './user.errors.js';
+export * from './user.register.js';
+export * from './user.checkIsExist.js';
+export type * from './user.repository';

package/dist/runtime/server/modules/users/index.js

@@ -0,0 +1,4 @@
+export * from "./user.validator.js";
+export * from "./user.errors.js";
+export * from "./user.register.js";
+export * from "./user.checkIsExist.js";

package/dist/runtime/server/modules/users/user.checkIsExist.d.ts

@@ -0,0 +1,14 @@
+import type { User } from '~/generated/prisma/client';
+import type { IUserRepository } from './user.repository.js';
+/**
+ * Verifica si existe un usuario con el ID proporcionado en la base de datos.
+ *
+ * Realiza una consulta con Prisma para buscar el usuario por su identificador.
+ * Si no se encuentra ningún registro, lanza un error de negocio con el código "UNREGISTER".
+ *
+ * @param userRepository - Repositorio de usuarios para realizar la consulta.
+ * @param userId - Identificador único del usuario a verificar.
+ * @returns Promesa que se resuelve sin valor si el usuario existe.
+ * @throws Error si el usuario no está registrado (código "UNREGISTER").
+ */
+export declare function userCheckIsExist(userRepository: Partial<IUserRepository>, userId: User['id']): Promise<void>;

package/dist/runtime/server/modules/users/user.checkIsExist.js

@@ -0,0 +1,8 @@
+import { userErrors } from "./user.errors.js";
+export async function userCheckIsExist(userRepository, userId) {
+  if (!userRepository?.findUniqueByUserId) throw userErrors.error("REPOSITORY_NOT_IMPLEMENTED");
+  const response = await userRepository.findUniqueByUserId(userId).catch(() => {
+    throw userErrors.error("INTERNAL_SERVER_ERROR");
+  });
+  if (!response) throw userErrors.error("UNREGISTER");
+}

package/dist/runtime/server/modules/users/user.errors.d.ts

@@ -0,0 +1,4 @@
+import { ErrorControler } from '../functions/errors/index.js';
+declare const userErrors: ErrorControler<"P2002" | "P2003" | "P2000" | "P2011" | "P2012" | "P2014" | "P2015" | "P2010" | "EMPTY" | "UNREGISTER" | "PASSWORD_NOT_VALID" | "PERSONID_NOT_VALID" | "REPOSITORY_NOT_IMPLEMENTED" | "REPOSITORY_USER_REGISTER_NOT_IMPLEMENTED" | "INTERNAL_SERVER_ERROR">;
+type UserErrorsCode = keyof typeof userErrors.errorMap;
+export { userErrors, UserErrorsCode };

package/dist/runtime/server/modules/users/user.errors.js

@@ -0,0 +1,64 @@
+import { ErrorControler } from "../functions/errors/index.js";
+const userErrors = new ErrorControler({
+  P2002: {
+    statusCode: 409,
+    message: "Restricci\xF3n de unicidad fallida. El usuario ya existe."
+  },
+  P2003: {
+    statusCode: 400,
+    message: "Fall\xF3 la restricci\xF3n de clave for\xE1nea. Referencia inv\xE1lida."
+  },
+  P2000: {
+    statusCode: 400,
+    message: "Valor demasiado largo para la columna."
+  },
+  P2011: {
+    statusCode: 400,
+    message: "Fall\xF3 la restricci\xF3n NOT NULL. Un campo obligatorio es nulo."
+  },
+  P2012: {
+    statusCode: 400,
+    message: "Falta un valor obligatorio."
+  },
+  P2014: {
+    statusCode: 400,
+    message: "Violaci\xF3n de relaci\xF3n obligatoria."
+  },
+  P2015: {
+    statusCode: 404,
+    message: "Registro relacionado no encontrado."
+  },
+  P2010: {
+    statusCode: 400,
+    message: "La consulta sin procesar fall\xF3."
+  },
+  EMPTY: {
+    statusCode: 400,
+    message: "No se aceptan valores vac\xEDos."
+  },
+  UNREGISTER: {
+    statusCode: 404,
+    message: "El usuario no est\xE1 registrado."
+  },
+  PASSWORD_NOT_VALID: {
+    statusCode: 400,
+    message: "La contrase\xF1a tiene un formato inv\xE1lido."
+  },
+  PERSONID_NOT_VALID: {
+    statusCode: 400,
+    message: "La c\xE9dula no contiene un formato v\xE1lido."
+  },
+  REPOSITORY_NOT_IMPLEMENTED: {
+    statusCode: 500,
+    message: "El repositorio de usuarios no est\xE1 implementado correctamente."
+  },
+  REPOSITORY_USER_REGISTER_NOT_IMPLEMENTED: {
+    statusCode: 500,
+    message: "El m\xE9todo userRegister del repositorio de usuarios no est\xE1 implementado."
+  },
+  INTERNAL_SERVER_ERROR: {
+    statusCode: 500,
+    message: "Error interno del servidor."
+  }
+});
+export { userErrors };

package/dist/runtime/server/modules/users/user.register.d.ts

@@ -0,0 +1,21 @@
+import type { User } from '~/generated/prisma/client';
+import type { IUserRepository } from './user.repository.js';
+export interface PayloadUserRegister extends Record<string, unknown> {
+    userName: User['userName'];
+    password: User['password'];
+    name: User['name'];
+    personId: User['personId'];
+    lastName: User['lastName'];
+}
+export declare function register(userRepository: Partial<IUserRepository>, user: PayloadUserRegister): Promise<{
+    sessionId: number | null;
+    name: string;
+    userName: string;
+    password: string;
+    lastName: string;
+    personId: string;
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    enable: boolean;
+}>;

package/dist/runtime/server/modules/users/user.register.js

@@ -0,0 +1,10 @@
+import { hashPassword } from "../functions/utils/hashPassword.js";
+import { userErrors } from "./user.errors.js";
+export async function register(userRepository, user) {
+  if (!userRepository?.userRegister) throw userErrors.error("REPOSITORY_USER_REGISTER_NOT_IMPLEMENTED");
+  const userCreated = await userRepository.userRegister({
+    ...user,
+    password: await hashPassword(user.password)
+  });
+  return userCreated;
+}

package/dist/runtime/server/modules/users/user.repository.d.ts

@@ -0,0 +1,10 @@
+import type { User } from '../../../../../playground/generated/prisma/client'
+import type { PayloadUserRegister } from './user.register'
+
+interface IUserRepository {
+  findUniqueByUserId(userId: User['id']): Promise<User | null>
+  userRegister(user: PayloadUserRegister): Promise<User>
+  findUniqueByUserName(userName: User['userName']): Promise<User | null>
+}
+
+export type { IUserRepository, User }